1// Code generated by models/protocol_tests/generate.go. DO NOT EDIT. 2 3package restjson_test 4 5import ( 6 "bytes" 7 "encoding/json" 8 "encoding/xml" 9 "fmt" 10 "io" 11 "io/ioutil" 12 "net/http" 13 "net/url" 14 "reflect" 15 "testing" 16 "time" 17 18 "github.com/aws/aws-sdk-go/aws" 19 "github.com/aws/aws-sdk-go/aws/client" 20 "github.com/aws/aws-sdk-go/aws/client/metadata" 21 "github.com/aws/aws-sdk-go/aws/request" 22 "github.com/aws/aws-sdk-go/aws/signer/v4" 23 "github.com/aws/aws-sdk-go/awstesting" 24 "github.com/aws/aws-sdk-go/awstesting/unit" 25 "github.com/aws/aws-sdk-go/private/protocol" 26 "github.com/aws/aws-sdk-go/private/protocol/restjson" 27 "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" 28 "github.com/aws/aws-sdk-go/private/util" 29) 30 31var _ bytes.Buffer // always import bytes 32var _ http.Request 33var _ json.Marshaler 34var _ time.Time 35var _ xmlutil.XMLNode 36var _ xml.Attr 37var _ = ioutil.Discard 38var _ = util.Trim("") 39var _ = url.Values{} 40var _ = io.EOF 41var _ = aws.String 42var _ = fmt.Println 43var _ = reflect.Value{} 44 45func init() { 46 protocol.RandReader = &awstesting.ZeroReader{} 47} 48 49// InputService1ProtocolTest provides the API operation methods for making requests to 50// . See this package's package overview docs 51// for details on the service. 52// 53// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to 54// modify mutate any of the struct's properties though. 55type InputService1ProtocolTest struct { 56 *client.Client 57} 58 59// New creates a new instance of the InputService1ProtocolTest client with a session. 60// If additional configuration is needed for the client instance use the optional 61// aws.Config parameter to add your extra config. 62// 63// Example: 64// mySession := session.Must(session.NewSession()) 65// 66// // Create a InputService1ProtocolTest client from just a session. 67// svc := inputservice1protocoltest.New(mySession) 68// 69// // Create a InputService1ProtocolTest client with additional configuration 70// svc := inputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 71func NewInputService1ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService1ProtocolTest { 72 c := p.ClientConfig("inputservice1protocoltest", cfgs...) 73 return newInputService1ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 74} 75 76// newClient creates, initializes and returns a new service client instance. 77func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService1ProtocolTest { 78 svc := &InputService1ProtocolTest{ 79 Client: client.New( 80 cfg, 81 metadata.ClientInfo{ 82 ServiceName: "InputService1ProtocolTest", 83 ServiceID: "InputService1ProtocolTest", 84 SigningName: signingName, 85 SigningRegion: signingRegion, 86 PartitionID: partitionID, 87 Endpoint: endpoint, 88 APIVersion: "2014-01-01", 89 }, 90 handlers, 91 ), 92 } 93 94 // Handlers 95 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 96 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 97 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 98 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 99 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 100 101 return svc 102} 103 104// newRequest creates a new request for a InputService1ProtocolTest operation and runs any 105// custom request initialization. 106func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 107 req := c.NewRequest(op, params, data) 108 109 return req 110} 111 112const opInputService1TestCaseOperation1 = "OperationName" 113 114// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the 115// client's request for the InputService1TestCaseOperation1 operation. The "output" return 116// value will be populated with the request's response once the request completes 117// successfully. 118// 119// Use "Send" method on the returned Request to send the API call to the service. 120// the "output" return value is not valid until after Send returns without error. 121// 122// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 123// API call, and error handling. 124// 125// This method is useful when you want to inject custom logic or configuration 126// into the SDK's request lifecycle. Such as custom headers, or retry logic. 127// 128// 129// // Example sending a request using the InputService1TestCaseOperation1Request method. 130// req, resp := client.InputService1TestCaseOperation1Request(params) 131// 132// err := req.Send() 133// if err == nil { // resp is now filled 134// fmt.Println(resp) 135// } 136func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputService1TestCaseOperation1Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { 137 op := &request.Operation{ 138 Name: opInputService1TestCaseOperation1, 139 HTTPMethod: "GET", 140 HTTPPath: "/2014-01-01/jobs", 141 } 142 143 if input == nil { 144 input = &InputService1TestShapeInputService1TestCaseOperation1Input{} 145 } 146 147 output = &InputService1TestShapeInputService1TestCaseOperation1Output{} 148 req = c.newRequest(op, input, output) 149 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 150 return 151} 152 153// InputService1TestCaseOperation1 API operation for . 154// 155// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 156// with awserr.Error's Code and Message methods to get detailed information about 157// the error. 158// 159// See the AWS API reference guide for 's 160// API operation InputService1TestCaseOperation1 for usage and error information. 161func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputService1TestCaseOperation1Input) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 162 req, out := c.InputService1TestCaseOperation1Request(input) 163 return out, req.Send() 164} 165 166// InputService1TestCaseOperation1WithContext is the same as InputService1TestCaseOperation1 with the addition of 167// the ability to pass a context and additional request options. 168// 169// See InputService1TestCaseOperation1 for details on how to use this API operation. 170// 171// The context must be non-nil and will be used for request cancellation. If 172// the context is nil a panic will occur. In the future the SDK may create 173// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 174// for more information on using Contexts. 175func (c *InputService1ProtocolTest) InputService1TestCaseOperation1WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation1Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 176 req, out := c.InputService1TestCaseOperation1Request(input) 177 req.SetContext(ctx) 178 req.ApplyOptions(opts...) 179 return out, req.Send() 180} 181 182type InputService1TestShapeInputService1TestCaseOperation1Input struct { 183 _ struct{} `type:"structure"` 184} 185 186type InputService1TestShapeInputService1TestCaseOperation1Output struct { 187 _ struct{} `type:"structure"` 188} 189 190// InputService2ProtocolTest provides the API operation methods for making requests to 191// . See this package's package overview docs 192// for details on the service. 193// 194// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 195// modify mutate any of the struct's properties though. 196type InputService2ProtocolTest struct { 197 *client.Client 198} 199 200// New creates a new instance of the InputService2ProtocolTest client with a session. 201// If additional configuration is needed for the client instance use the optional 202// aws.Config parameter to add your extra config. 203// 204// Example: 205// mySession := session.Must(session.NewSession()) 206// 207// // Create a InputService2ProtocolTest client from just a session. 208// svc := inputservice2protocoltest.New(mySession) 209// 210// // Create a InputService2ProtocolTest client with additional configuration 211// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 212func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 213 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 214 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 215} 216 217// newClient creates, initializes and returns a new service client instance. 218func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 219 svc := &InputService2ProtocolTest{ 220 Client: client.New( 221 cfg, 222 metadata.ClientInfo{ 223 ServiceName: "InputService2ProtocolTest", 224 ServiceID: "InputService2ProtocolTest", 225 SigningName: signingName, 226 SigningRegion: signingRegion, 227 PartitionID: partitionID, 228 Endpoint: endpoint, 229 APIVersion: "2014-01-01", 230 }, 231 handlers, 232 ), 233 } 234 235 // Handlers 236 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 237 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 238 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 239 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 240 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 241 242 return svc 243} 244 245// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 246// custom request initialization. 247func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 248 req := c.NewRequest(op, params, data) 249 250 return req 251} 252 253const opInputService2TestCaseOperation1 = "OperationName" 254 255// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 256// client's request for the InputService2TestCaseOperation1 operation. The "output" return 257// value will be populated with the request's response once the request completes 258// successfully. 259// 260// Use "Send" method on the returned Request to send the API call to the service. 261// the "output" return value is not valid until after Send returns without error. 262// 263// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 264// API call, and error handling. 265// 266// This method is useful when you want to inject custom logic or configuration 267// into the SDK's request lifecycle. Such as custom headers, or retry logic. 268// 269// 270// // Example sending a request using the InputService2TestCaseOperation1Request method. 271// req, resp := client.InputService2TestCaseOperation1Request(params) 272// 273// err := req.Send() 274// if err == nil { // resp is now filled 275// fmt.Println(resp) 276// } 277func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 278 op := &request.Operation{ 279 Name: opInputService2TestCaseOperation1, 280 HTTPMethod: "GET", 281 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 282 } 283 284 if input == nil { 285 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 286 } 287 288 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 289 req = c.newRequest(op, input, output) 290 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 291 return 292} 293 294// InputService2TestCaseOperation1 API operation for . 295// 296// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 297// with awserr.Error's Code and Message methods to get detailed information about 298// the error. 299// 300// See the AWS API reference guide for 's 301// API operation InputService2TestCaseOperation1 for usage and error information. 302func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 303 req, out := c.InputService2TestCaseOperation1Request(input) 304 return out, req.Send() 305} 306 307// InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of 308// the ability to pass a context and additional request options. 309// 310// See InputService2TestCaseOperation1 for details on how to use this API operation. 311// 312// The context must be non-nil and will be used for request cancellation. If 313// the context is nil a panic will occur. In the future the SDK may create 314// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 315// for more information on using Contexts. 316func (c *InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input *InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 317 req, out := c.InputService2TestCaseOperation1Request(input) 318 req.SetContext(ctx) 319 req.ApplyOptions(opts...) 320 return out, req.Send() 321} 322 323type InputService2TestShapeInputService2TestCaseOperation1Input struct { 324 _ struct{} `type:"structure"` 325 326 // PipelineId is a required field 327 PipelineId *string `location:"uri" type:"string" required:"true"` 328} 329 330// Validate inspects the fields of the type to determine if they are valid. 331func (s *InputService2TestShapeInputService2TestCaseOperation1Input) Validate() error { 332 invalidParams := request.ErrInvalidParams{Context: "InputService2TestShapeInputService2TestCaseOperation1Input"} 333 if s.PipelineId == nil { 334 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 335 } 336 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 337 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 338 } 339 340 if invalidParams.Len() > 0 { 341 return invalidParams 342 } 343 return nil 344} 345 346// SetPipelineId sets the PipelineId field's value. 347func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetPipelineId(v string) *InputService2TestShapeInputService2TestCaseOperation1Input { 348 s.PipelineId = &v 349 return s 350} 351 352type InputService2TestShapeInputService2TestCaseOperation1Output struct { 353 _ struct{} `type:"structure"` 354} 355 356// InputService3ProtocolTest provides the API operation methods for making requests to 357// . See this package's package overview docs 358// for details on the service. 359// 360// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to 361// modify mutate any of the struct's properties though. 362type InputService3ProtocolTest struct { 363 *client.Client 364} 365 366// New creates a new instance of the InputService3ProtocolTest client with a session. 367// If additional configuration is needed for the client instance use the optional 368// aws.Config parameter to add your extra config. 369// 370// Example: 371// mySession := session.Must(session.NewSession()) 372// 373// // Create a InputService3ProtocolTest client from just a session. 374// svc := inputservice3protocoltest.New(mySession) 375// 376// // Create a InputService3ProtocolTest client with additional configuration 377// svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 378func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService3ProtocolTest { 379 c := p.ClientConfig("inputservice3protocoltest", cfgs...) 380 return newInputService3ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 381} 382 383// newClient creates, initializes and returns a new service client instance. 384func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService3ProtocolTest { 385 svc := &InputService3ProtocolTest{ 386 Client: client.New( 387 cfg, 388 metadata.ClientInfo{ 389 ServiceName: "InputService3ProtocolTest", 390 ServiceID: "InputService3ProtocolTest", 391 SigningName: signingName, 392 SigningRegion: signingRegion, 393 PartitionID: partitionID, 394 Endpoint: endpoint, 395 APIVersion: "2014-01-01", 396 }, 397 handlers, 398 ), 399 } 400 401 // Handlers 402 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 403 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 404 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 405 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 406 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 407 408 return svc 409} 410 411// newRequest creates a new request for a InputService3ProtocolTest operation and runs any 412// custom request initialization. 413func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 414 req := c.NewRequest(op, params, data) 415 416 return req 417} 418 419const opInputService3TestCaseOperation1 = "OperationName" 420 421// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 422// client's request for the InputService3TestCaseOperation1 operation. The "output" return 423// value will be populated with the request's response once the request completes 424// successfully. 425// 426// Use "Send" method on the returned Request to send the API call to the service. 427// the "output" return value is not valid until after Send returns without error. 428// 429// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 430// API call, and error handling. 431// 432// This method is useful when you want to inject custom logic or configuration 433// into the SDK's request lifecycle. Such as custom headers, or retry logic. 434// 435// 436// // Example sending a request using the InputService3TestCaseOperation1Request method. 437// req, resp := client.InputService3TestCaseOperation1Request(params) 438// 439// err := req.Send() 440// if err == nil { // resp is now filled 441// fmt.Println(resp) 442// } 443func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation1Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { 444 op := &request.Operation{ 445 Name: opInputService3TestCaseOperation1, 446 HTTPMethod: "GET", 447 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 448 } 449 450 if input == nil { 451 input = &InputService3TestShapeInputService3TestCaseOperation1Input{} 452 } 453 454 output = &InputService3TestShapeInputService3TestCaseOperation1Output{} 455 req = c.newRequest(op, input, output) 456 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 457 return 458} 459 460// InputService3TestCaseOperation1 API operation for . 461// 462// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 463// with awserr.Error's Code and Message methods to get detailed information about 464// the error. 465// 466// See the AWS API reference guide for 's 467// API operation InputService3TestCaseOperation1 for usage and error information. 468func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation1Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 469 req, out := c.InputService3TestCaseOperation1Request(input) 470 return out, req.Send() 471} 472 473// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 474// the ability to pass a context and additional request options. 475// 476// See InputService3TestCaseOperation1 for details on how to use this API operation. 477// 478// The context must be non-nil and will be used for request cancellation. If 479// the context is nil a panic will occur. In the future the SDK may create 480// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 481// for more information on using Contexts. 482func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation1Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 483 req, out := c.InputService3TestCaseOperation1Request(input) 484 req.SetContext(ctx) 485 req.ApplyOptions(opts...) 486 return out, req.Send() 487} 488 489type InputService3TestShapeInputService3TestCaseOperation1Input struct { 490 _ struct{} `type:"structure"` 491 492 // Foo is a required field 493 Foo *string `location:"uri" locationName:"PipelineId" type:"string" required:"true"` 494} 495 496// Validate inspects the fields of the type to determine if they are valid. 497func (s *InputService3TestShapeInputService3TestCaseOperation1Input) Validate() error { 498 invalidParams := request.ErrInvalidParams{Context: "InputService3TestShapeInputService3TestCaseOperation1Input"} 499 if s.Foo == nil { 500 invalidParams.Add(request.NewErrParamRequired("Foo")) 501 } 502 if s.Foo != nil && len(*s.Foo) < 1 { 503 invalidParams.Add(request.NewErrParamMinLen("Foo", 1)) 504 } 505 506 if invalidParams.Len() > 0 { 507 return invalidParams 508 } 509 return nil 510} 511 512// SetFoo sets the Foo field's value. 513func (s *InputService3TestShapeInputService3TestCaseOperation1Input) SetFoo(v string) *InputService3TestShapeInputService3TestCaseOperation1Input { 514 s.Foo = &v 515 return s 516} 517 518type InputService3TestShapeInputService3TestCaseOperation1Output struct { 519 _ struct{} `type:"structure"` 520} 521 522// InputService4ProtocolTest provides the API operation methods for making requests to 523// . See this package's package overview docs 524// for details on the service. 525// 526// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 527// modify mutate any of the struct's properties though. 528type InputService4ProtocolTest struct { 529 *client.Client 530} 531 532// New creates a new instance of the InputService4ProtocolTest client with a session. 533// If additional configuration is needed for the client instance use the optional 534// aws.Config parameter to add your extra config. 535// 536// Example: 537// mySession := session.Must(session.NewSession()) 538// 539// // Create a InputService4ProtocolTest client from just a session. 540// svc := inputservice4protocoltest.New(mySession) 541// 542// // Create a InputService4ProtocolTest client with additional configuration 543// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 544func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 545 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 546 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 547} 548 549// newClient creates, initializes and returns a new service client instance. 550func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 551 svc := &InputService4ProtocolTest{ 552 Client: client.New( 553 cfg, 554 metadata.ClientInfo{ 555 ServiceName: "InputService4ProtocolTest", 556 ServiceID: "InputService4ProtocolTest", 557 SigningName: signingName, 558 SigningRegion: signingRegion, 559 PartitionID: partitionID, 560 Endpoint: endpoint, 561 APIVersion: "2014-01-01", 562 }, 563 handlers, 564 ), 565 } 566 567 // Handlers 568 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 569 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 570 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 571 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 572 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 573 574 return svc 575} 576 577// newRequest creates a new request for a InputService4ProtocolTest operation and runs any 578// custom request initialization. 579func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 580 req := c.NewRequest(op, params, data) 581 582 return req 583} 584 585const opInputService4TestCaseOperation1 = "OperationName" 586 587// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 588// client's request for the InputService4TestCaseOperation1 operation. The "output" return 589// value will be populated with the request's response once the request completes 590// successfully. 591// 592// Use "Send" method on the returned Request to send the API call to the service. 593// the "output" return value is not valid until after Send returns without error. 594// 595// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 596// API call, and error handling. 597// 598// This method is useful when you want to inject custom logic or configuration 599// into the SDK's request lifecycle. Such as custom headers, or retry logic. 600// 601// 602// // Example sending a request using the InputService4TestCaseOperation1Request method. 603// req, resp := client.InputService4TestCaseOperation1Request(params) 604// 605// err := req.Send() 606// if err == nil { // resp is now filled 607// fmt.Println(resp) 608// } 609func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation1Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { 610 op := &request.Operation{ 611 Name: opInputService4TestCaseOperation1, 612 HTTPMethod: "GET", 613 HTTPPath: "/path", 614 } 615 616 if input == nil { 617 input = &InputService4TestShapeInputService4TestCaseOperation1Input{} 618 } 619 620 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 621 req = c.newRequest(op, input, output) 622 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 623 return 624} 625 626// InputService4TestCaseOperation1 API operation for . 627// 628// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 629// with awserr.Error's Code and Message methods to get detailed information about 630// the error. 631// 632// See the AWS API reference guide for 's 633// API operation InputService4TestCaseOperation1 for usage and error information. 634func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 635 req, out := c.InputService4TestCaseOperation1Request(input) 636 return out, req.Send() 637} 638 639// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 640// the ability to pass a context and additional request options. 641// 642// See InputService4TestCaseOperation1 for details on how to use this API operation. 643// 644// The context must be non-nil and will be used for request cancellation. If 645// the context is nil a panic will occur. In the future the SDK may create 646// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 647// for more information on using Contexts. 648func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 649 req, out := c.InputService4TestCaseOperation1Request(input) 650 req.SetContext(ctx) 651 req.ApplyOptions(opts...) 652 return out, req.Send() 653} 654 655type InputService4TestShapeInputService4TestCaseOperation1Input struct { 656 _ struct{} `type:"structure"` 657 658 Items []*string `location:"querystring" locationName:"item" type:"list"` 659} 660 661// SetItems sets the Items field's value. 662func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetItems(v []*string) *InputService4TestShapeInputService4TestCaseOperation1Input { 663 s.Items = v 664 return s 665} 666 667type InputService4TestShapeInputService4TestCaseOperation1Output struct { 668 _ struct{} `type:"structure"` 669} 670 671// InputService5ProtocolTest provides the API operation methods for making requests to 672// . See this package's package overview docs 673// for details on the service. 674// 675// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 676// modify mutate any of the struct's properties though. 677type InputService5ProtocolTest struct { 678 *client.Client 679} 680 681// New creates a new instance of the InputService5ProtocolTest client with a session. 682// If additional configuration is needed for the client instance use the optional 683// aws.Config parameter to add your extra config. 684// 685// Example: 686// mySession := session.Must(session.NewSession()) 687// 688// // Create a InputService5ProtocolTest client from just a session. 689// svc := inputservice5protocoltest.New(mySession) 690// 691// // Create a InputService5ProtocolTest client with additional configuration 692// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 693func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 694 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 695 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 696} 697 698// newClient creates, initializes and returns a new service client instance. 699func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 700 svc := &InputService5ProtocolTest{ 701 Client: client.New( 702 cfg, 703 metadata.ClientInfo{ 704 ServiceName: "InputService5ProtocolTest", 705 ServiceID: "InputService5ProtocolTest", 706 SigningName: signingName, 707 SigningRegion: signingRegion, 708 PartitionID: partitionID, 709 Endpoint: endpoint, 710 APIVersion: "2014-01-01", 711 }, 712 handlers, 713 ), 714 } 715 716 // Handlers 717 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 718 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 719 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 720 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 721 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 722 723 return svc 724} 725 726// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 727// custom request initialization. 728func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 729 req := c.NewRequest(op, params, data) 730 731 return req 732} 733 734const opInputService5TestCaseOperation1 = "OperationName" 735 736// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 737// client's request for the InputService5TestCaseOperation1 operation. The "output" return 738// value will be populated with the request's response once the request completes 739// successfully. 740// 741// Use "Send" method on the returned Request to send the API call to the service. 742// the "output" return value is not valid until after Send returns without error. 743// 744// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 745// API call, and error handling. 746// 747// This method is useful when you want to inject custom logic or configuration 748// into the SDK's request lifecycle. Such as custom headers, or retry logic. 749// 750// 751// // Example sending a request using the InputService5TestCaseOperation1Request method. 752// req, resp := client.InputService5TestCaseOperation1Request(params) 753// 754// err := req.Send() 755// if err == nil { // resp is now filled 756// fmt.Println(resp) 757// } 758func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 759 op := &request.Operation{ 760 Name: opInputService5TestCaseOperation1, 761 HTTPMethod: "GET", 762 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 763 } 764 765 if input == nil { 766 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 767 } 768 769 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 770 req = c.newRequest(op, input, output) 771 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 772 return 773} 774 775// InputService5TestCaseOperation1 API operation for . 776// 777// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 778// with awserr.Error's Code and Message methods to get detailed information about 779// the error. 780// 781// See the AWS API reference guide for 's 782// API operation InputService5TestCaseOperation1 for usage and error information. 783func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 784 req, out := c.InputService5TestCaseOperation1Request(input) 785 return out, req.Send() 786} 787 788// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 789// the ability to pass a context and additional request options. 790// 791// See InputService5TestCaseOperation1 for details on how to use this API operation. 792// 793// The context must be non-nil and will be used for request cancellation. If 794// the context is nil a panic will occur. In the future the SDK may create 795// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 796// for more information on using Contexts. 797func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 798 req, out := c.InputService5TestCaseOperation1Request(input) 799 req.SetContext(ctx) 800 req.ApplyOptions(opts...) 801 return out, req.Send() 802} 803 804type InputService5TestShapeInputService5TestCaseOperation1Input struct { 805 _ struct{} `type:"structure"` 806 807 // PipelineId is a required field 808 PipelineId *string `location:"uri" type:"string" required:"true"` 809 810 QueryDoc map[string]*string `location:"querystring" type:"map"` 811} 812 813// Validate inspects the fields of the type to determine if they are valid. 814func (s *InputService5TestShapeInputService5TestCaseOperation1Input) Validate() error { 815 invalidParams := request.ErrInvalidParams{Context: "InputService5TestShapeInputService5TestCaseOperation1Input"} 816 if s.PipelineId == nil { 817 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 818 } 819 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 820 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 821 } 822 823 if invalidParams.Len() > 0 { 824 return invalidParams 825 } 826 return nil 827} 828 829// SetPipelineId sets the PipelineId field's value. 830func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetPipelineId(v string) *InputService5TestShapeInputService5TestCaseOperation1Input { 831 s.PipelineId = &v 832 return s 833} 834 835// SetQueryDoc sets the QueryDoc field's value. 836func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetQueryDoc(v map[string]*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 837 s.QueryDoc = v 838 return s 839} 840 841type InputService5TestShapeInputService5TestCaseOperation1Output struct { 842 _ struct{} `type:"structure"` 843} 844 845// InputService6ProtocolTest provides the API operation methods for making requests to 846// . See this package's package overview docs 847// for details on the service. 848// 849// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 850// modify mutate any of the struct's properties though. 851type InputService6ProtocolTest struct { 852 *client.Client 853} 854 855// New creates a new instance of the InputService6ProtocolTest client with a session. 856// If additional configuration is needed for the client instance use the optional 857// aws.Config parameter to add your extra config. 858// 859// Example: 860// mySession := session.Must(session.NewSession()) 861// 862// // Create a InputService6ProtocolTest client from just a session. 863// svc := inputservice6protocoltest.New(mySession) 864// 865// // Create a InputService6ProtocolTest client with additional configuration 866// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 867func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 868 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 869 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 870} 871 872// newClient creates, initializes and returns a new service client instance. 873func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 874 svc := &InputService6ProtocolTest{ 875 Client: client.New( 876 cfg, 877 metadata.ClientInfo{ 878 ServiceName: "InputService6ProtocolTest", 879 ServiceID: "InputService6ProtocolTest", 880 SigningName: signingName, 881 SigningRegion: signingRegion, 882 PartitionID: partitionID, 883 Endpoint: endpoint, 884 APIVersion: "2014-01-01", 885 }, 886 handlers, 887 ), 888 } 889 890 // Handlers 891 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 892 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 893 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 894 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 895 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 896 897 return svc 898} 899 900// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 901// custom request initialization. 902func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 903 req := c.NewRequest(op, params, data) 904 905 return req 906} 907 908const opInputService6TestCaseOperation1 = "OperationName" 909 910// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 911// client's request for the InputService6TestCaseOperation1 operation. The "output" return 912// value will be populated with the request's response once the request completes 913// successfully. 914// 915// Use "Send" method on the returned Request to send the API call to the service. 916// the "output" return value is not valid until after Send returns without error. 917// 918// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 919// API call, and error handling. 920// 921// This method is useful when you want to inject custom logic or configuration 922// into the SDK's request lifecycle. Such as custom headers, or retry logic. 923// 924// 925// // Example sending a request using the InputService6TestCaseOperation1Request method. 926// req, resp := client.InputService6TestCaseOperation1Request(params) 927// 928// err := req.Send() 929// if err == nil { // resp is now filled 930// fmt.Println(resp) 931// } 932func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 933 op := &request.Operation{ 934 Name: opInputService6TestCaseOperation1, 935 HTTPMethod: "GET", 936 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 937 } 938 939 if input == nil { 940 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 941 } 942 943 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 944 req = c.newRequest(op, input, output) 945 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 946 return 947} 948 949// InputService6TestCaseOperation1 API operation for . 950// 951// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 952// with awserr.Error's Code and Message methods to get detailed information about 953// the error. 954// 955// See the AWS API reference guide for 's 956// API operation InputService6TestCaseOperation1 for usage and error information. 957func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 958 req, out := c.InputService6TestCaseOperation1Request(input) 959 return out, req.Send() 960} 961 962// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 963// the ability to pass a context and additional request options. 964// 965// See InputService6TestCaseOperation1 for details on how to use this API operation. 966// 967// The context must be non-nil and will be used for request cancellation. If 968// the context is nil a panic will occur. In the future the SDK may create 969// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 970// for more information on using Contexts. 971func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 972 req, out := c.InputService6TestCaseOperation1Request(input) 973 req.SetContext(ctx) 974 req.ApplyOptions(opts...) 975 return out, req.Send() 976} 977 978type InputService6TestShapeInputService6TestCaseOperation1Input struct { 979 _ struct{} `type:"structure"` 980 981 // PipelineId is a required field 982 PipelineId *string `location:"uri" type:"string" required:"true"` 983 984 QueryDoc map[string][]*string `location:"querystring" type:"map"` 985} 986 987// Validate inspects the fields of the type to determine if they are valid. 988func (s *InputService6TestShapeInputService6TestCaseOperation1Input) Validate() error { 989 invalidParams := request.ErrInvalidParams{Context: "InputService6TestShapeInputService6TestCaseOperation1Input"} 990 if s.PipelineId == nil { 991 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 992 } 993 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 994 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 995 } 996 997 if invalidParams.Len() > 0 { 998 return invalidParams 999 } 1000 return nil 1001} 1002 1003// SetPipelineId sets the PipelineId field's value. 1004func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetPipelineId(v string) *InputService6TestShapeInputService6TestCaseOperation1Input { 1005 s.PipelineId = &v 1006 return s 1007} 1008 1009// SetQueryDoc sets the QueryDoc field's value. 1010func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetQueryDoc(v map[string][]*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 1011 s.QueryDoc = v 1012 return s 1013} 1014 1015type InputService6TestShapeInputService6TestCaseOperation1Output struct { 1016 _ struct{} `type:"structure"` 1017} 1018 1019// InputService7ProtocolTest provides the API operation methods for making requests to 1020// . See this package's package overview docs 1021// for details on the service. 1022// 1023// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 1024// modify mutate any of the struct's properties though. 1025type InputService7ProtocolTest struct { 1026 *client.Client 1027} 1028 1029// New creates a new instance of the InputService7ProtocolTest client with a session. 1030// If additional configuration is needed for the client instance use the optional 1031// aws.Config parameter to add your extra config. 1032// 1033// Example: 1034// mySession := session.Must(session.NewSession()) 1035// 1036// // Create a InputService7ProtocolTest client from just a session. 1037// svc := inputservice7protocoltest.New(mySession) 1038// 1039// // Create a InputService7ProtocolTest client with additional configuration 1040// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1041func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1042 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1043 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 1044} 1045 1046// newClient creates, initializes and returns a new service client instance. 1047func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1048 svc := &InputService7ProtocolTest{ 1049 Client: client.New( 1050 cfg, 1051 metadata.ClientInfo{ 1052 ServiceName: "InputService7ProtocolTest", 1053 ServiceID: "InputService7ProtocolTest", 1054 SigningName: signingName, 1055 SigningRegion: signingRegion, 1056 PartitionID: partitionID, 1057 Endpoint: endpoint, 1058 APIVersion: "2014-01-01", 1059 }, 1060 handlers, 1061 ), 1062 } 1063 1064 // Handlers 1065 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1066 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 1067 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 1068 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 1069 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 1070 1071 return svc 1072} 1073 1074// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1075// custom request initialization. 1076func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1077 req := c.NewRequest(op, params, data) 1078 1079 return req 1080} 1081 1082const opInputService7TestCaseOperation1 = "OperationName" 1083 1084// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1085// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1086// value will be populated with the request's response once the request completes 1087// successfully. 1088// 1089// Use "Send" method on the returned Request to send the API call to the service. 1090// the "output" return value is not valid until after Send returns without error. 1091// 1092// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1093// API call, and error handling. 1094// 1095// This method is useful when you want to inject custom logic or configuration 1096// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1097// 1098// 1099// // Example sending a request using the InputService7TestCaseOperation1Request method. 1100// req, resp := client.InputService7TestCaseOperation1Request(params) 1101// 1102// err := req.Send() 1103// if err == nil { // resp is now filled 1104// fmt.Println(resp) 1105// } 1106func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1107 op := &request.Operation{ 1108 Name: opInputService7TestCaseOperation1, 1109 HTTPMethod: "GET", 1110 HTTPPath: "/path", 1111 } 1112 1113 if input == nil { 1114 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1115 } 1116 1117 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1118 req = c.newRequest(op, input, output) 1119 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1120 return 1121} 1122 1123// InputService7TestCaseOperation1 API operation for . 1124// 1125// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1126// with awserr.Error's Code and Message methods to get detailed information about 1127// the error. 1128// 1129// See the AWS API reference guide for 's 1130// API operation InputService7TestCaseOperation1 for usage and error information. 1131func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1132 req, out := c.InputService7TestCaseOperation1Request(input) 1133 return out, req.Send() 1134} 1135 1136// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1137// the ability to pass a context and additional request options. 1138// 1139// See InputService7TestCaseOperation1 for details on how to use this API operation. 1140// 1141// The context must be non-nil and will be used for request cancellation. If 1142// the context is nil a panic will occur. In the future the SDK may create 1143// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1144// for more information on using Contexts. 1145func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1146 req, out := c.InputService7TestCaseOperation1Request(input) 1147 req.SetContext(ctx) 1148 req.ApplyOptions(opts...) 1149 return out, req.Send() 1150} 1151 1152const opInputService7TestCaseOperation2 = "OperationName" 1153 1154// InputService7TestCaseOperation2Request generates a "aws/request.Request" representing the 1155// client's request for the InputService7TestCaseOperation2 operation. The "output" return 1156// value will be populated with the request's response once the request completes 1157// successfully. 1158// 1159// Use "Send" method on the returned Request to send the API call to the service. 1160// the "output" return value is not valid until after Send returns without error. 1161// 1162// See InputService7TestCaseOperation2 for more information on using the InputService7TestCaseOperation2 1163// API call, and error handling. 1164// 1165// This method is useful when you want to inject custom logic or configuration 1166// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1167// 1168// 1169// // Example sending a request using the InputService7TestCaseOperation2Request method. 1170// req, resp := client.InputService7TestCaseOperation2Request(params) 1171// 1172// err := req.Send() 1173// if err == nil { // resp is now filled 1174// fmt.Println(resp) 1175// } 1176func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input *InputService7TestShapeInputService7TestCaseOperation2Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation2Output) { 1177 op := &request.Operation{ 1178 Name: opInputService7TestCaseOperation2, 1179 HTTPMethod: "GET", 1180 HTTPPath: "/path", 1181 } 1182 1183 if input == nil { 1184 input = &InputService7TestShapeInputService7TestCaseOperation2Input{} 1185 } 1186 1187 output = &InputService7TestShapeInputService7TestCaseOperation2Output{} 1188 req = c.newRequest(op, input, output) 1189 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1190 return 1191} 1192 1193// InputService7TestCaseOperation2 API operation for . 1194// 1195// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1196// with awserr.Error's Code and Message methods to get detailed information about 1197// the error. 1198// 1199// See the AWS API reference guide for 's 1200// API operation InputService7TestCaseOperation2 for usage and error information. 1201func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *InputService7TestShapeInputService7TestCaseOperation2Input) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) { 1202 req, out := c.InputService7TestCaseOperation2Request(input) 1203 return out, req.Send() 1204} 1205 1206// InputService7TestCaseOperation2WithContext is the same as InputService7TestCaseOperation2 with the addition of 1207// the ability to pass a context and additional request options. 1208// 1209// See InputService7TestCaseOperation2 for details on how to use this API operation. 1210// 1211// The context must be non-nil and will be used for request cancellation. If 1212// the context is nil a panic will occur. In the future the SDK may create 1213// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1214// for more information on using Contexts. 1215func (c *InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) { 1216 req, out := c.InputService7TestCaseOperation2Request(input) 1217 req.SetContext(ctx) 1218 req.ApplyOptions(opts...) 1219 return out, req.Send() 1220} 1221 1222type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1223 _ struct{} `type:"structure"` 1224 1225 BoolQuery *bool `location:"querystring" locationName:"bool-query" type:"boolean"` 1226} 1227 1228// SetBoolQuery sets the BoolQuery field's value. 1229func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetBoolQuery(v bool) *InputService7TestShapeInputService7TestCaseOperation1Input { 1230 s.BoolQuery = &v 1231 return s 1232} 1233 1234type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1235 _ struct{} `type:"structure"` 1236} 1237 1238type InputService7TestShapeInputService7TestCaseOperation2Input struct { 1239 _ struct{} `type:"structure"` 1240 1241 BoolQuery *bool `location:"querystring" locationName:"bool-query" type:"boolean"` 1242} 1243 1244// SetBoolQuery sets the BoolQuery field's value. 1245func (s *InputService7TestShapeInputService7TestCaseOperation2Input) SetBoolQuery(v bool) *InputService7TestShapeInputService7TestCaseOperation2Input { 1246 s.BoolQuery = &v 1247 return s 1248} 1249 1250type InputService7TestShapeInputService7TestCaseOperation2Output struct { 1251 _ struct{} `type:"structure"` 1252} 1253 1254// InputService8ProtocolTest provides the API operation methods for making requests to 1255// . See this package's package overview docs 1256// for details on the service. 1257// 1258// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1259// modify mutate any of the struct's properties though. 1260type InputService8ProtocolTest struct { 1261 *client.Client 1262} 1263 1264// New creates a new instance of the InputService8ProtocolTest client with a session. 1265// If additional configuration is needed for the client instance use the optional 1266// aws.Config parameter to add your extra config. 1267// 1268// Example: 1269// mySession := session.Must(session.NewSession()) 1270// 1271// // Create a InputService8ProtocolTest client from just a session. 1272// svc := inputservice8protocoltest.New(mySession) 1273// 1274// // Create a InputService8ProtocolTest client with additional configuration 1275// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1276func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1277 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1278 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 1279} 1280 1281// newClient creates, initializes and returns a new service client instance. 1282func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1283 svc := &InputService8ProtocolTest{ 1284 Client: client.New( 1285 cfg, 1286 metadata.ClientInfo{ 1287 ServiceName: "InputService8ProtocolTest", 1288 ServiceID: "InputService8ProtocolTest", 1289 SigningName: signingName, 1290 SigningRegion: signingRegion, 1291 PartitionID: partitionID, 1292 Endpoint: endpoint, 1293 APIVersion: "2014-01-01", 1294 }, 1295 handlers, 1296 ), 1297 } 1298 1299 // Handlers 1300 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1301 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 1302 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 1303 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 1304 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 1305 1306 return svc 1307} 1308 1309// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1310// custom request initialization. 1311func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1312 req := c.NewRequest(op, params, data) 1313 1314 return req 1315} 1316 1317const opInputService8TestCaseOperation1 = "OperationName" 1318 1319// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1320// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1321// value will be populated with the request's response once the request completes 1322// successfully. 1323// 1324// Use "Send" method on the returned Request to send the API call to the service. 1325// the "output" return value is not valid until after Send returns without error. 1326// 1327// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1328// API call, and error handling. 1329// 1330// This method is useful when you want to inject custom logic or configuration 1331// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1332// 1333// 1334// // Example sending a request using the InputService8TestCaseOperation1Request method. 1335// req, resp := client.InputService8TestCaseOperation1Request(params) 1336// 1337// err := req.Send() 1338// if err == nil { // resp is now filled 1339// fmt.Println(resp) 1340// } 1341func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1342 op := &request.Operation{ 1343 Name: opInputService8TestCaseOperation1, 1344 HTTPMethod: "GET", 1345 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 1346 } 1347 1348 if input == nil { 1349 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1350 } 1351 1352 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1353 req = c.newRequest(op, input, output) 1354 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1355 return 1356} 1357 1358// InputService8TestCaseOperation1 API operation for . 1359// 1360// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1361// with awserr.Error's Code and Message methods to get detailed information about 1362// the error. 1363// 1364// See the AWS API reference guide for 's 1365// API operation InputService8TestCaseOperation1 for usage and error information. 1366func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1367 req, out := c.InputService8TestCaseOperation1Request(input) 1368 return out, req.Send() 1369} 1370 1371// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1372// the ability to pass a context and additional request options. 1373// 1374// See InputService8TestCaseOperation1 for details on how to use this API operation. 1375// 1376// The context must be non-nil and will be used for request cancellation. If 1377// the context is nil a panic will occur. In the future the SDK may create 1378// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1379// for more information on using Contexts. 1380func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1381 req, out := c.InputService8TestCaseOperation1Request(input) 1382 req.SetContext(ctx) 1383 req.ApplyOptions(opts...) 1384 return out, req.Send() 1385} 1386 1387type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1388 _ struct{} `type:"structure"` 1389 1390 Ascending *string `location:"querystring" locationName:"Ascending" type:"string"` 1391 1392 PageToken *string `location:"querystring" locationName:"PageToken" type:"string"` 1393 1394 // PipelineId is a required field 1395 PipelineId *string `location:"uri" locationName:"PipelineId" type:"string" required:"true"` 1396} 1397 1398// Validate inspects the fields of the type to determine if they are valid. 1399func (s *InputService8TestShapeInputService8TestCaseOperation1Input) Validate() error { 1400 invalidParams := request.ErrInvalidParams{Context: "InputService8TestShapeInputService8TestCaseOperation1Input"} 1401 if s.PipelineId == nil { 1402 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 1403 } 1404 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 1405 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 1406 } 1407 1408 if invalidParams.Len() > 0 { 1409 return invalidParams 1410 } 1411 return nil 1412} 1413 1414// SetAscending sets the Ascending field's value. 1415func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetAscending(v string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1416 s.Ascending = &v 1417 return s 1418} 1419 1420// SetPageToken sets the PageToken field's value. 1421func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetPageToken(v string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1422 s.PageToken = &v 1423 return s 1424} 1425 1426// SetPipelineId sets the PipelineId field's value. 1427func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetPipelineId(v string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1428 s.PipelineId = &v 1429 return s 1430} 1431 1432type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1433 _ struct{} `type:"structure"` 1434} 1435 1436// InputService9ProtocolTest provides the API operation methods for making requests to 1437// . See this package's package overview docs 1438// for details on the service. 1439// 1440// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1441// modify mutate any of the struct's properties though. 1442type InputService9ProtocolTest struct { 1443 *client.Client 1444} 1445 1446// New creates a new instance of the InputService9ProtocolTest client with a session. 1447// If additional configuration is needed for the client instance use the optional 1448// aws.Config parameter to add your extra config. 1449// 1450// Example: 1451// mySession := session.Must(session.NewSession()) 1452// 1453// // Create a InputService9ProtocolTest client from just a session. 1454// svc := inputservice9protocoltest.New(mySession) 1455// 1456// // Create a InputService9ProtocolTest client with additional configuration 1457// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1458func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1459 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1460 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 1461} 1462 1463// newClient creates, initializes and returns a new service client instance. 1464func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1465 svc := &InputService9ProtocolTest{ 1466 Client: client.New( 1467 cfg, 1468 metadata.ClientInfo{ 1469 ServiceName: "InputService9ProtocolTest", 1470 ServiceID: "InputService9ProtocolTest", 1471 SigningName: signingName, 1472 SigningRegion: signingRegion, 1473 PartitionID: partitionID, 1474 Endpoint: endpoint, 1475 APIVersion: "2014-01-01", 1476 }, 1477 handlers, 1478 ), 1479 } 1480 1481 // Handlers 1482 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1483 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 1484 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 1485 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 1486 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 1487 1488 return svc 1489} 1490 1491// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1492// custom request initialization. 1493func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1494 req := c.NewRequest(op, params, data) 1495 1496 return req 1497} 1498 1499const opInputService9TestCaseOperation1 = "OperationName" 1500 1501// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1502// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1503// value will be populated with the request's response once the request completes 1504// successfully. 1505// 1506// Use "Send" method on the returned Request to send the API call to the service. 1507// the "output" return value is not valid until after Send returns without error. 1508// 1509// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1510// API call, and error handling. 1511// 1512// This method is useful when you want to inject custom logic or configuration 1513// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1514// 1515// 1516// // Example sending a request using the InputService9TestCaseOperation1Request method. 1517// req, resp := client.InputService9TestCaseOperation1Request(params) 1518// 1519// err := req.Send() 1520// if err == nil { // resp is now filled 1521// fmt.Println(resp) 1522// } 1523func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1524 op := &request.Operation{ 1525 Name: opInputService9TestCaseOperation1, 1526 HTTPMethod: "POST", 1527 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 1528 } 1529 1530 if input == nil { 1531 input = &InputService9TestShapeInputService9TestCaseOperation1Input{} 1532 } 1533 1534 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1535 req = c.newRequest(op, input, output) 1536 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1537 return 1538} 1539 1540// InputService9TestCaseOperation1 API operation for . 1541// 1542// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1543// with awserr.Error's Code and Message methods to get detailed information about 1544// the error. 1545// 1546// See the AWS API reference guide for 's 1547// API operation InputService9TestCaseOperation1 for usage and error information. 1548func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1549 req, out := c.InputService9TestCaseOperation1Request(input) 1550 return out, req.Send() 1551} 1552 1553// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1554// the ability to pass a context and additional request options. 1555// 1556// See InputService9TestCaseOperation1 for details on how to use this API operation. 1557// 1558// The context must be non-nil and will be used for request cancellation. If 1559// the context is nil a panic will occur. In the future the SDK may create 1560// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1561// for more information on using Contexts. 1562func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1563 req, out := c.InputService9TestCaseOperation1Request(input) 1564 req.SetContext(ctx) 1565 req.ApplyOptions(opts...) 1566 return out, req.Send() 1567} 1568 1569type InputService9TestShapeInputService9TestCaseOperation1Input struct { 1570 _ struct{} `type:"structure"` 1571 1572 Ascending *string `location:"querystring" locationName:"Ascending" type:"string"` 1573 1574 Config *InputService9TestShapeStructType `type:"structure"` 1575 1576 PageToken *string `location:"querystring" locationName:"PageToken" type:"string"` 1577 1578 // PipelineId is a required field 1579 PipelineId *string `location:"uri" locationName:"PipelineId" type:"string" required:"true"` 1580} 1581 1582// Validate inspects the fields of the type to determine if they are valid. 1583func (s *InputService9TestShapeInputService9TestCaseOperation1Input) Validate() error { 1584 invalidParams := request.ErrInvalidParams{Context: "InputService9TestShapeInputService9TestCaseOperation1Input"} 1585 if s.PipelineId == nil { 1586 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 1587 } 1588 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 1589 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 1590 } 1591 1592 if invalidParams.Len() > 0 { 1593 return invalidParams 1594 } 1595 return nil 1596} 1597 1598// SetAscending sets the Ascending field's value. 1599func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetAscending(v string) *InputService9TestShapeInputService9TestCaseOperation1Input { 1600 s.Ascending = &v 1601 return s 1602} 1603 1604// SetConfig sets the Config field's value. 1605func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetConfig(v *InputService9TestShapeStructType) *InputService9TestShapeInputService9TestCaseOperation1Input { 1606 s.Config = v 1607 return s 1608} 1609 1610// SetPageToken sets the PageToken field's value. 1611func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetPageToken(v string) *InputService9TestShapeInputService9TestCaseOperation1Input { 1612 s.PageToken = &v 1613 return s 1614} 1615 1616// SetPipelineId sets the PipelineId field's value. 1617func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetPipelineId(v string) *InputService9TestShapeInputService9TestCaseOperation1Input { 1618 s.PipelineId = &v 1619 return s 1620} 1621 1622type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1623 _ struct{} `type:"structure"` 1624} 1625 1626type InputService9TestShapeStructType struct { 1627 _ struct{} `type:"structure"` 1628 1629 A *string `type:"string"` 1630 1631 B *string `type:"string"` 1632} 1633 1634// SetA sets the A field's value. 1635func (s *InputService9TestShapeStructType) SetA(v string) *InputService9TestShapeStructType { 1636 s.A = &v 1637 return s 1638} 1639 1640// SetB sets the B field's value. 1641func (s *InputService9TestShapeStructType) SetB(v string) *InputService9TestShapeStructType { 1642 s.B = &v 1643 return s 1644} 1645 1646// InputService10ProtocolTest provides the API operation methods for making requests to 1647// . See this package's package overview docs 1648// for details on the service. 1649// 1650// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1651// modify mutate any of the struct's properties though. 1652type InputService10ProtocolTest struct { 1653 *client.Client 1654} 1655 1656// New creates a new instance of the InputService10ProtocolTest client with a session. 1657// If additional configuration is needed for the client instance use the optional 1658// aws.Config parameter to add your extra config. 1659// 1660// Example: 1661// mySession := session.Must(session.NewSession()) 1662// 1663// // Create a InputService10ProtocolTest client from just a session. 1664// svc := inputservice10protocoltest.New(mySession) 1665// 1666// // Create a InputService10ProtocolTest client with additional configuration 1667// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1668func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1669 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1670 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 1671} 1672 1673// newClient creates, initializes and returns a new service client instance. 1674func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1675 svc := &InputService10ProtocolTest{ 1676 Client: client.New( 1677 cfg, 1678 metadata.ClientInfo{ 1679 ServiceName: "InputService10ProtocolTest", 1680 ServiceID: "InputService10ProtocolTest", 1681 SigningName: signingName, 1682 SigningRegion: signingRegion, 1683 PartitionID: partitionID, 1684 Endpoint: endpoint, 1685 APIVersion: "2014-01-01", 1686 }, 1687 handlers, 1688 ), 1689 } 1690 1691 // Handlers 1692 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1693 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 1694 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 1695 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 1696 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 1697 1698 return svc 1699} 1700 1701// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1702// custom request initialization. 1703func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1704 req := c.NewRequest(op, params, data) 1705 1706 return req 1707} 1708 1709const opInputService10TestCaseOperation1 = "OperationName" 1710 1711// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1712// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1713// value will be populated with the request's response once the request completes 1714// successfully. 1715// 1716// Use "Send" method on the returned Request to send the API call to the service. 1717// the "output" return value is not valid until after Send returns without error. 1718// 1719// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1720// API call, and error handling. 1721// 1722// This method is useful when you want to inject custom logic or configuration 1723// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1724// 1725// 1726// // Example sending a request using the InputService10TestCaseOperation1Request method. 1727// req, resp := client.InputService10TestCaseOperation1Request(params) 1728// 1729// err := req.Send() 1730// if err == nil { // resp is now filled 1731// fmt.Println(resp) 1732// } 1733func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1734 op := &request.Operation{ 1735 Name: opInputService10TestCaseOperation1, 1736 HTTPMethod: "POST", 1737 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 1738 } 1739 1740 if input == nil { 1741 input = &InputService10TestShapeInputService10TestCaseOperation1Input{} 1742 } 1743 1744 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1745 req = c.newRequest(op, input, output) 1746 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1747 return 1748} 1749 1750// InputService10TestCaseOperation1 API operation for . 1751// 1752// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1753// with awserr.Error's Code and Message methods to get detailed information about 1754// the error. 1755// 1756// See the AWS API reference guide for 's 1757// API operation InputService10TestCaseOperation1 for usage and error information. 1758func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1759 req, out := c.InputService10TestCaseOperation1Request(input) 1760 return out, req.Send() 1761} 1762 1763// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1764// the ability to pass a context and additional request options. 1765// 1766// See InputService10TestCaseOperation1 for details on how to use this API operation. 1767// 1768// The context must be non-nil and will be used for request cancellation. If 1769// the context is nil a panic will occur. In the future the SDK may create 1770// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1771// for more information on using Contexts. 1772func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1773 req, out := c.InputService10TestCaseOperation1Request(input) 1774 req.SetContext(ctx) 1775 req.ApplyOptions(opts...) 1776 return out, req.Send() 1777} 1778 1779type InputService10TestShapeInputService10TestCaseOperation1Input struct { 1780 _ struct{} `type:"structure"` 1781 1782 Ascending *string `location:"querystring" locationName:"Ascending" type:"string"` 1783 1784 Checksum *string `location:"header" locationName:"x-amz-checksum" type:"string"` 1785 1786 Config *InputService10TestShapeStructType `type:"structure"` 1787 1788 PageToken *string `location:"querystring" locationName:"PageToken" type:"string"` 1789 1790 // PipelineId is a required field 1791 PipelineId *string `location:"uri" locationName:"PipelineId" type:"string" required:"true"` 1792} 1793 1794// Validate inspects the fields of the type to determine if they are valid. 1795func (s *InputService10TestShapeInputService10TestCaseOperation1Input) Validate() error { 1796 invalidParams := request.ErrInvalidParams{Context: "InputService10TestShapeInputService10TestCaseOperation1Input"} 1797 if s.PipelineId == nil { 1798 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 1799 } 1800 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 1801 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 1802 } 1803 1804 if invalidParams.Len() > 0 { 1805 return invalidParams 1806 } 1807 return nil 1808} 1809 1810// SetAscending sets the Ascending field's value. 1811func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetAscending(v string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1812 s.Ascending = &v 1813 return s 1814} 1815 1816// SetChecksum sets the Checksum field's value. 1817func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetChecksum(v string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1818 s.Checksum = &v 1819 return s 1820} 1821 1822// SetConfig sets the Config field's value. 1823func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetConfig(v *InputService10TestShapeStructType) *InputService10TestShapeInputService10TestCaseOperation1Input { 1824 s.Config = v 1825 return s 1826} 1827 1828// SetPageToken sets the PageToken field's value. 1829func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetPageToken(v string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1830 s.PageToken = &v 1831 return s 1832} 1833 1834// SetPipelineId sets the PipelineId field's value. 1835func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetPipelineId(v string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1836 s.PipelineId = &v 1837 return s 1838} 1839 1840type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1841 _ struct{} `type:"structure"` 1842} 1843 1844type InputService10TestShapeStructType struct { 1845 _ struct{} `type:"structure"` 1846 1847 A *string `type:"string"` 1848 1849 B *string `type:"string"` 1850} 1851 1852// SetA sets the A field's value. 1853func (s *InputService10TestShapeStructType) SetA(v string) *InputService10TestShapeStructType { 1854 s.A = &v 1855 return s 1856} 1857 1858// SetB sets the B field's value. 1859func (s *InputService10TestShapeStructType) SetB(v string) *InputService10TestShapeStructType { 1860 s.B = &v 1861 return s 1862} 1863 1864// InputService11ProtocolTest provides the API operation methods for making requests to 1865// . See this package's package overview docs 1866// for details on the service. 1867// 1868// InputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1869// modify mutate any of the struct's properties though. 1870type InputService11ProtocolTest struct { 1871 *client.Client 1872} 1873 1874// New creates a new instance of the InputService11ProtocolTest client with a session. 1875// If additional configuration is needed for the client instance use the optional 1876// aws.Config parameter to add your extra config. 1877// 1878// Example: 1879// mySession := session.Must(session.NewSession()) 1880// 1881// // Create a InputService11ProtocolTest client from just a session. 1882// svc := inputservice11protocoltest.New(mySession) 1883// 1884// // Create a InputService11ProtocolTest client with additional configuration 1885// svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1886func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService11ProtocolTest { 1887 c := p.ClientConfig("inputservice11protocoltest", cfgs...) 1888 return newInputService11ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 1889} 1890 1891// newClient creates, initializes and returns a new service client instance. 1892func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService11ProtocolTest { 1893 svc := &InputService11ProtocolTest{ 1894 Client: client.New( 1895 cfg, 1896 metadata.ClientInfo{ 1897 ServiceName: "InputService11ProtocolTest", 1898 ServiceID: "InputService11ProtocolTest", 1899 SigningName: signingName, 1900 SigningRegion: signingRegion, 1901 PartitionID: partitionID, 1902 Endpoint: endpoint, 1903 APIVersion: "2014-01-01", 1904 }, 1905 handlers, 1906 ), 1907 } 1908 1909 // Handlers 1910 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1911 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 1912 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 1913 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 1914 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 1915 1916 return svc 1917} 1918 1919// newRequest creates a new request for a InputService11ProtocolTest operation and runs any 1920// custom request initialization. 1921func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1922 req := c.NewRequest(op, params, data) 1923 1924 return req 1925} 1926 1927const opInputService11TestCaseOperation1 = "OperationName" 1928 1929// InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1930// client's request for the InputService11TestCaseOperation1 operation. The "output" return 1931// value will be populated with the request's response once the request completes 1932// successfully. 1933// 1934// Use "Send" method on the returned Request to send the API call to the service. 1935// the "output" return value is not valid until after Send returns without error. 1936// 1937// See InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 1938// API call, and error handling. 1939// 1940// This method is useful when you want to inject custom logic or configuration 1941// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1942// 1943// 1944// // Example sending a request using the InputService11TestCaseOperation1Request method. 1945// req, resp := client.InputService11TestCaseOperation1Request(params) 1946// 1947// err := req.Send() 1948// if err == nil { // resp is now filled 1949// fmt.Println(resp) 1950// } 1951func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { 1952 op := &request.Operation{ 1953 Name: opInputService11TestCaseOperation1, 1954 HTTPMethod: "POST", 1955 HTTPPath: "/2014-01-01/vaults/{vaultName}/archives", 1956 } 1957 1958 if input == nil { 1959 input = &InputService11TestShapeInputService11TestCaseOperation1Input{} 1960 } 1961 1962 output = &InputService11TestShapeInputService11TestCaseOperation1Output{} 1963 req = c.newRequest(op, input, output) 1964 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1965 return 1966} 1967 1968// InputService11TestCaseOperation1 API operation for . 1969// 1970// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1971// with awserr.Error's Code and Message methods to get detailed information about 1972// the error. 1973// 1974// See the AWS API reference guide for 's 1975// API operation InputService11TestCaseOperation1 for usage and error information. 1976func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1977 req, out := c.InputService11TestCaseOperation1Request(input) 1978 return out, req.Send() 1979} 1980 1981// InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of 1982// the ability to pass a context and additional request options. 1983// 1984// See InputService11TestCaseOperation1 for details on how to use this API operation. 1985// 1986// The context must be non-nil and will be used for request cancellation. If 1987// the context is nil a panic will occur. In the future the SDK may create 1988// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1989// for more information on using Contexts. 1990func (c *InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1991 req, out := c.InputService11TestCaseOperation1Request(input) 1992 req.SetContext(ctx) 1993 req.ApplyOptions(opts...) 1994 return out, req.Send() 1995} 1996 1997type InputService11TestShapeInputService11TestCaseOperation1Input struct { 1998 _ struct{} `type:"structure" payload:"Body"` 1999 2000 Body io.ReadSeeker `locationName:"body" type:"blob"` 2001 2002 Checksum *string `location:"header" locationName:"x-amz-sha256-tree-hash" type:"string"` 2003 2004 // VaultName is a required field 2005 VaultName *string `location:"uri" locationName:"vaultName" type:"string" required:"true"` 2006} 2007 2008// Validate inspects the fields of the type to determine if they are valid. 2009func (s *InputService11TestShapeInputService11TestCaseOperation1Input) Validate() error { 2010 invalidParams := request.ErrInvalidParams{Context: "InputService11TestShapeInputService11TestCaseOperation1Input"} 2011 if s.VaultName == nil { 2012 invalidParams.Add(request.NewErrParamRequired("VaultName")) 2013 } 2014 if s.VaultName != nil && len(*s.VaultName) < 1 { 2015 invalidParams.Add(request.NewErrParamMinLen("VaultName", 1)) 2016 } 2017 2018 if invalidParams.Len() > 0 { 2019 return invalidParams 2020 } 2021 return nil 2022} 2023 2024// SetBody sets the Body field's value. 2025func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetBody(v io.ReadSeeker) *InputService11TestShapeInputService11TestCaseOperation1Input { 2026 s.Body = v 2027 return s 2028} 2029 2030// SetChecksum sets the Checksum field's value. 2031func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetChecksum(v string) *InputService11TestShapeInputService11TestCaseOperation1Input { 2032 s.Checksum = &v 2033 return s 2034} 2035 2036// SetVaultName sets the VaultName field's value. 2037func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetVaultName(v string) *InputService11TestShapeInputService11TestCaseOperation1Input { 2038 s.VaultName = &v 2039 return s 2040} 2041 2042type InputService11TestShapeInputService11TestCaseOperation1Output struct { 2043 _ struct{} `type:"structure"` 2044} 2045 2046// InputService12ProtocolTest provides the API operation methods for making requests to 2047// . See this package's package overview docs 2048// for details on the service. 2049// 2050// InputService12ProtocolTest methods are safe to use concurrently. It is not safe to 2051// modify mutate any of the struct's properties though. 2052type InputService12ProtocolTest struct { 2053 *client.Client 2054} 2055 2056// New creates a new instance of the InputService12ProtocolTest client with a session. 2057// If additional configuration is needed for the client instance use the optional 2058// aws.Config parameter to add your extra config. 2059// 2060// Example: 2061// mySession := session.Must(session.NewSession()) 2062// 2063// // Create a InputService12ProtocolTest client from just a session. 2064// svc := inputservice12protocoltest.New(mySession) 2065// 2066// // Create a InputService12ProtocolTest client with additional configuration 2067// svc := inputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2068func NewInputService12ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService12ProtocolTest { 2069 c := p.ClientConfig("inputservice12protocoltest", cfgs...) 2070 return newInputService12ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 2071} 2072 2073// newClient creates, initializes and returns a new service client instance. 2074func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService12ProtocolTest { 2075 svc := &InputService12ProtocolTest{ 2076 Client: client.New( 2077 cfg, 2078 metadata.ClientInfo{ 2079 ServiceName: "InputService12ProtocolTest", 2080 ServiceID: "InputService12ProtocolTest", 2081 SigningName: signingName, 2082 SigningRegion: signingRegion, 2083 PartitionID: partitionID, 2084 Endpoint: endpoint, 2085 APIVersion: "2014-01-01", 2086 }, 2087 handlers, 2088 ), 2089 } 2090 2091 // Handlers 2092 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2093 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 2094 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 2095 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 2096 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 2097 2098 return svc 2099} 2100 2101// newRequest creates a new request for a InputService12ProtocolTest operation and runs any 2102// custom request initialization. 2103func (c *InputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2104 req := c.NewRequest(op, params, data) 2105 2106 return req 2107} 2108 2109const opInputService12TestCaseOperation1 = "OperationName" 2110 2111// InputService12TestCaseOperation1Request generates a "aws/request.Request" representing the 2112// client's request for the InputService12TestCaseOperation1 operation. The "output" return 2113// value will be populated with the request's response once the request completes 2114// successfully. 2115// 2116// Use "Send" method on the returned Request to send the API call to the service. 2117// the "output" return value is not valid until after Send returns without error. 2118// 2119// See InputService12TestCaseOperation1 for more information on using the InputService12TestCaseOperation1 2120// API call, and error handling. 2121// 2122// This method is useful when you want to inject custom logic or configuration 2123// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2124// 2125// 2126// // Example sending a request using the InputService12TestCaseOperation1Request method. 2127// req, resp := client.InputService12TestCaseOperation1Request(params) 2128// 2129// err := req.Send() 2130// if err == nil { // resp is now filled 2131// fmt.Println(resp) 2132// } 2133func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputService12TestCaseOperation1Input) (req *request.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) { 2134 op := &request.Operation{ 2135 Name: opInputService12TestCaseOperation1, 2136 HTTPMethod: "POST", 2137 HTTPPath: "/2014-01-01/{Foo}", 2138 } 2139 2140 if input == nil { 2141 input = &InputService12TestShapeInputService12TestCaseOperation1Input{} 2142 } 2143 2144 output = &InputService12TestShapeInputService12TestCaseOperation1Output{} 2145 req = c.newRequest(op, input, output) 2146 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2147 return 2148} 2149 2150// InputService12TestCaseOperation1 API operation for . 2151// 2152// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2153// with awserr.Error's Code and Message methods to get detailed information about 2154// the error. 2155// 2156// See the AWS API reference guide for 's 2157// API operation InputService12TestCaseOperation1 for usage and error information. 2158func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputService12TestCaseOperation1Input) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2159 req, out := c.InputService12TestCaseOperation1Request(input) 2160 return out, req.Send() 2161} 2162 2163// InputService12TestCaseOperation1WithContext is the same as InputService12TestCaseOperation1 with the addition of 2164// the ability to pass a context and additional request options. 2165// 2166// See InputService12TestCaseOperation1 for details on how to use this API operation. 2167// 2168// The context must be non-nil and will be used for request cancellation. If 2169// the context is nil a panic will occur. In the future the SDK may create 2170// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2171// for more information on using Contexts. 2172func (c *InputService12ProtocolTest) InputService12TestCaseOperation1WithContext(ctx aws.Context, input *InputService12TestShapeInputService12TestCaseOperation1Input, opts ...request.Option) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2173 req, out := c.InputService12TestCaseOperation1Request(input) 2174 req.SetContext(ctx) 2175 req.ApplyOptions(opts...) 2176 return out, req.Send() 2177} 2178 2179type InputService12TestShapeInputService12TestCaseOperation1Input struct { 2180 _ struct{} `type:"structure"` 2181 2182 // Bar is automatically base64 encoded/decoded by the SDK. 2183 Bar []byte `type:"blob"` 2184 2185 // Foo is a required field 2186 Foo *string `location:"uri" locationName:"Foo" type:"string" required:"true"` 2187} 2188 2189// Validate inspects the fields of the type to determine if they are valid. 2190func (s *InputService12TestShapeInputService12TestCaseOperation1Input) Validate() error { 2191 invalidParams := request.ErrInvalidParams{Context: "InputService12TestShapeInputService12TestCaseOperation1Input"} 2192 if s.Foo == nil { 2193 invalidParams.Add(request.NewErrParamRequired("Foo")) 2194 } 2195 if s.Foo != nil && len(*s.Foo) < 1 { 2196 invalidParams.Add(request.NewErrParamMinLen("Foo", 1)) 2197 } 2198 2199 if invalidParams.Len() > 0 { 2200 return invalidParams 2201 } 2202 return nil 2203} 2204 2205// SetBar sets the Bar field's value. 2206func (s *InputService12TestShapeInputService12TestCaseOperation1Input) SetBar(v []byte) *InputService12TestShapeInputService12TestCaseOperation1Input { 2207 s.Bar = v 2208 return s 2209} 2210 2211// SetFoo sets the Foo field's value. 2212func (s *InputService12TestShapeInputService12TestCaseOperation1Input) SetFoo(v string) *InputService12TestShapeInputService12TestCaseOperation1Input { 2213 s.Foo = &v 2214 return s 2215} 2216 2217type InputService12TestShapeInputService12TestCaseOperation1Output struct { 2218 _ struct{} `type:"structure"` 2219} 2220 2221// InputService13ProtocolTest provides the API operation methods for making requests to 2222// . See this package's package overview docs 2223// for details on the service. 2224// 2225// InputService13ProtocolTest methods are safe to use concurrently. It is not safe to 2226// modify mutate any of the struct's properties though. 2227type InputService13ProtocolTest struct { 2228 *client.Client 2229} 2230 2231// New creates a new instance of the InputService13ProtocolTest client with a session. 2232// If additional configuration is needed for the client instance use the optional 2233// aws.Config parameter to add your extra config. 2234// 2235// Example: 2236// mySession := session.Must(session.NewSession()) 2237// 2238// // Create a InputService13ProtocolTest client from just a session. 2239// svc := inputservice13protocoltest.New(mySession) 2240// 2241// // Create a InputService13ProtocolTest client with additional configuration 2242// svc := inputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2243func NewInputService13ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService13ProtocolTest { 2244 c := p.ClientConfig("inputservice13protocoltest", cfgs...) 2245 return newInputService13ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 2246} 2247 2248// newClient creates, initializes and returns a new service client instance. 2249func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService13ProtocolTest { 2250 svc := &InputService13ProtocolTest{ 2251 Client: client.New( 2252 cfg, 2253 metadata.ClientInfo{ 2254 ServiceName: "InputService13ProtocolTest", 2255 ServiceID: "InputService13ProtocolTest", 2256 SigningName: signingName, 2257 SigningRegion: signingRegion, 2258 PartitionID: partitionID, 2259 Endpoint: endpoint, 2260 APIVersion: "2014-01-01", 2261 }, 2262 handlers, 2263 ), 2264 } 2265 2266 // Handlers 2267 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2268 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 2269 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 2270 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 2271 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 2272 2273 return svc 2274} 2275 2276// newRequest creates a new request for a InputService13ProtocolTest operation and runs any 2277// custom request initialization. 2278func (c *InputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2279 req := c.NewRequest(op, params, data) 2280 2281 return req 2282} 2283 2284const opInputService13TestCaseOperation1 = "OperationName" 2285 2286// InputService13TestCaseOperation1Request generates a "aws/request.Request" representing the 2287// client's request for the InputService13TestCaseOperation1 operation. The "output" return 2288// value will be populated with the request's response once the request completes 2289// successfully. 2290// 2291// Use "Send" method on the returned Request to send the API call to the service. 2292// the "output" return value is not valid until after Send returns without error. 2293// 2294// See InputService13TestCaseOperation1 for more information on using the InputService13TestCaseOperation1 2295// API call, and error handling. 2296// 2297// This method is useful when you want to inject custom logic or configuration 2298// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2299// 2300// 2301// // Example sending a request using the InputService13TestCaseOperation1Request method. 2302// req, resp := client.InputService13TestCaseOperation1Request(params) 2303// 2304// err := req.Send() 2305// if err == nil { // resp is now filled 2306// fmt.Println(resp) 2307// } 2308func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputService13TestCaseOperation1Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) { 2309 op := &request.Operation{ 2310 Name: opInputService13TestCaseOperation1, 2311 HTTPMethod: "POST", 2312 HTTPPath: "/", 2313 } 2314 2315 if input == nil { 2316 input = &InputService13TestShapeInputService13TestCaseOperation1Input{} 2317 } 2318 2319 output = &InputService13TestShapeInputService13TestCaseOperation1Output{} 2320 req = c.newRequest(op, input, output) 2321 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2322 return 2323} 2324 2325// InputService13TestCaseOperation1 API operation for . 2326// 2327// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2328// with awserr.Error's Code and Message methods to get detailed information about 2329// the error. 2330// 2331// See the AWS API reference guide for 's 2332// API operation InputService13TestCaseOperation1 for usage and error information. 2333func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputService13TestCaseOperation1Input) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2334 req, out := c.InputService13TestCaseOperation1Request(input) 2335 return out, req.Send() 2336} 2337 2338// InputService13TestCaseOperation1WithContext is the same as InputService13TestCaseOperation1 with the addition of 2339// the ability to pass a context and additional request options. 2340// 2341// See InputService13TestCaseOperation1 for details on how to use this API operation. 2342// 2343// The context must be non-nil and will be used for request cancellation. If 2344// the context is nil a panic will occur. In the future the SDK may create 2345// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2346// for more information on using Contexts. 2347func (c *InputService13ProtocolTest) InputService13TestCaseOperation1WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation1Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2348 req, out := c.InputService13TestCaseOperation1Request(input) 2349 req.SetContext(ctx) 2350 req.ApplyOptions(opts...) 2351 return out, req.Send() 2352} 2353 2354const opInputService13TestCaseOperation2 = "OperationName" 2355 2356// InputService13TestCaseOperation2Request generates a "aws/request.Request" representing the 2357// client's request for the InputService13TestCaseOperation2 operation. The "output" return 2358// value will be populated with the request's response once the request completes 2359// successfully. 2360// 2361// Use "Send" method on the returned Request to send the API call to the service. 2362// the "output" return value is not valid until after Send returns without error. 2363// 2364// See InputService13TestCaseOperation2 for more information on using the InputService13TestCaseOperation2 2365// API call, and error handling. 2366// 2367// This method is useful when you want to inject custom logic or configuration 2368// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2369// 2370// 2371// // Example sending a request using the InputService13TestCaseOperation2Request method. 2372// req, resp := client.InputService13TestCaseOperation2Request(params) 2373// 2374// err := req.Send() 2375// if err == nil { // resp is now filled 2376// fmt.Println(resp) 2377// } 2378func (c *InputService13ProtocolTest) InputService13TestCaseOperation2Request(input *InputService13TestShapeInputService13TestCaseOperation2Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation2Output) { 2379 op := &request.Operation{ 2380 Name: opInputService13TestCaseOperation2, 2381 HTTPMethod: "POST", 2382 HTTPPath: "/", 2383 } 2384 2385 if input == nil { 2386 input = &InputService13TestShapeInputService13TestCaseOperation2Input{} 2387 } 2388 2389 output = &InputService13TestShapeInputService13TestCaseOperation2Output{} 2390 req = c.newRequest(op, input, output) 2391 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2392 return 2393} 2394 2395// InputService13TestCaseOperation2 API operation for . 2396// 2397// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2398// with awserr.Error's Code and Message methods to get detailed information about 2399// the error. 2400// 2401// See the AWS API reference guide for 's 2402// API operation InputService13TestCaseOperation2 for usage and error information. 2403func (c *InputService13ProtocolTest) InputService13TestCaseOperation2(input *InputService13TestShapeInputService13TestCaseOperation2Input) (*InputService13TestShapeInputService13TestCaseOperation2Output, error) { 2404 req, out := c.InputService13TestCaseOperation2Request(input) 2405 return out, req.Send() 2406} 2407 2408// InputService13TestCaseOperation2WithContext is the same as InputService13TestCaseOperation2 with the addition of 2409// the ability to pass a context and additional request options. 2410// 2411// See InputService13TestCaseOperation2 for details on how to use this API operation. 2412// 2413// The context must be non-nil and will be used for request cancellation. If 2414// the context is nil a panic will occur. In the future the SDK may create 2415// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2416// for more information on using Contexts. 2417func (c *InputService13ProtocolTest) InputService13TestCaseOperation2WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation2Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation2Output, error) { 2418 req, out := c.InputService13TestCaseOperation2Request(input) 2419 req.SetContext(ctx) 2420 req.ApplyOptions(opts...) 2421 return out, req.Send() 2422} 2423 2424type InputService13TestShapeInputService13TestCaseOperation1Input struct { 2425 _ struct{} `type:"structure" payload:"Foo"` 2426 2427 Foo []byte `locationName:"foo" type:"blob"` 2428} 2429 2430// SetFoo sets the Foo field's value. 2431func (s *InputService13TestShapeInputService13TestCaseOperation1Input) SetFoo(v []byte) *InputService13TestShapeInputService13TestCaseOperation1Input { 2432 s.Foo = v 2433 return s 2434} 2435 2436type InputService13TestShapeInputService13TestCaseOperation1Output struct { 2437 _ struct{} `type:"structure"` 2438} 2439 2440type InputService13TestShapeInputService13TestCaseOperation2Input struct { 2441 _ struct{} `type:"structure" payload:"Foo"` 2442 2443 Foo []byte `locationName:"foo" type:"blob"` 2444} 2445 2446// SetFoo sets the Foo field's value. 2447func (s *InputService13TestShapeInputService13TestCaseOperation2Input) SetFoo(v []byte) *InputService13TestShapeInputService13TestCaseOperation2Input { 2448 s.Foo = v 2449 return s 2450} 2451 2452type InputService13TestShapeInputService13TestCaseOperation2Output struct { 2453 _ struct{} `type:"structure"` 2454} 2455 2456// InputService14ProtocolTest provides the API operation methods for making requests to 2457// . See this package's package overview docs 2458// for details on the service. 2459// 2460// InputService14ProtocolTest methods are safe to use concurrently. It is not safe to 2461// modify mutate any of the struct's properties though. 2462type InputService14ProtocolTest struct { 2463 *client.Client 2464} 2465 2466// New creates a new instance of the InputService14ProtocolTest client with a session. 2467// If additional configuration is needed for the client instance use the optional 2468// aws.Config parameter to add your extra config. 2469// 2470// Example: 2471// mySession := session.Must(session.NewSession()) 2472// 2473// // Create a InputService14ProtocolTest client from just a session. 2474// svc := inputservice14protocoltest.New(mySession) 2475// 2476// // Create a InputService14ProtocolTest client with additional configuration 2477// svc := inputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2478func NewInputService14ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService14ProtocolTest { 2479 c := p.ClientConfig("inputservice14protocoltest", cfgs...) 2480 return newInputService14ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 2481} 2482 2483// newClient creates, initializes and returns a new service client instance. 2484func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService14ProtocolTest { 2485 svc := &InputService14ProtocolTest{ 2486 Client: client.New( 2487 cfg, 2488 metadata.ClientInfo{ 2489 ServiceName: "InputService14ProtocolTest", 2490 ServiceID: "InputService14ProtocolTest", 2491 SigningName: signingName, 2492 SigningRegion: signingRegion, 2493 PartitionID: partitionID, 2494 Endpoint: endpoint, 2495 APIVersion: "2014-01-01", 2496 }, 2497 handlers, 2498 ), 2499 } 2500 2501 // Handlers 2502 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2503 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 2504 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 2505 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 2506 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 2507 2508 return svc 2509} 2510 2511// newRequest creates a new request for a InputService14ProtocolTest operation and runs any 2512// custom request initialization. 2513func (c *InputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2514 req := c.NewRequest(op, params, data) 2515 2516 return req 2517} 2518 2519const opInputService14TestCaseOperation1 = "OperationName" 2520 2521// InputService14TestCaseOperation1Request generates a "aws/request.Request" representing the 2522// client's request for the InputService14TestCaseOperation1 operation. The "output" return 2523// value will be populated with the request's response once the request completes 2524// successfully. 2525// 2526// Use "Send" method on the returned Request to send the API call to the service. 2527// the "output" return value is not valid until after Send returns without error. 2528// 2529// See InputService14TestCaseOperation1 for more information on using the InputService14TestCaseOperation1 2530// API call, and error handling. 2531// 2532// This method is useful when you want to inject custom logic or configuration 2533// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2534// 2535// 2536// // Example sending a request using the InputService14TestCaseOperation1Request method. 2537// req, resp := client.InputService14TestCaseOperation1Request(params) 2538// 2539// err := req.Send() 2540// if err == nil { // resp is now filled 2541// fmt.Println(resp) 2542// } 2543func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputService14TestCaseOperation1Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) { 2544 op := &request.Operation{ 2545 Name: opInputService14TestCaseOperation1, 2546 HTTPMethod: "POST", 2547 HTTPPath: "/", 2548 } 2549 2550 if input == nil { 2551 input = &InputService14TestShapeInputService14TestCaseOperation1Input{} 2552 } 2553 2554 output = &InputService14TestShapeInputService14TestCaseOperation1Output{} 2555 req = c.newRequest(op, input, output) 2556 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2557 return 2558} 2559 2560// InputService14TestCaseOperation1 API operation for . 2561// 2562// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2563// with awserr.Error's Code and Message methods to get detailed information about 2564// the error. 2565// 2566// See the AWS API reference guide for 's 2567// API operation InputService14TestCaseOperation1 for usage and error information. 2568func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputService14TestCaseOperation1Input) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2569 req, out := c.InputService14TestCaseOperation1Request(input) 2570 return out, req.Send() 2571} 2572 2573// InputService14TestCaseOperation1WithContext is the same as InputService14TestCaseOperation1 with the addition of 2574// the ability to pass a context and additional request options. 2575// 2576// See InputService14TestCaseOperation1 for details on how to use this API operation. 2577// 2578// The context must be non-nil and will be used for request cancellation. If 2579// the context is nil a panic will occur. In the future the SDK may create 2580// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2581// for more information on using Contexts. 2582func (c *InputService14ProtocolTest) InputService14TestCaseOperation1WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation1Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2583 req, out := c.InputService14TestCaseOperation1Request(input) 2584 req.SetContext(ctx) 2585 req.ApplyOptions(opts...) 2586 return out, req.Send() 2587} 2588 2589const opInputService14TestCaseOperation2 = "OperationName" 2590 2591// InputService14TestCaseOperation2Request generates a "aws/request.Request" representing the 2592// client's request for the InputService14TestCaseOperation2 operation. The "output" return 2593// value will be populated with the request's response once the request completes 2594// successfully. 2595// 2596// Use "Send" method on the returned Request to send the API call to the service. 2597// the "output" return value is not valid until after Send returns without error. 2598// 2599// See InputService14TestCaseOperation2 for more information on using the InputService14TestCaseOperation2 2600// API call, and error handling. 2601// 2602// This method is useful when you want to inject custom logic or configuration 2603// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2604// 2605// 2606// // Example sending a request using the InputService14TestCaseOperation2Request method. 2607// req, resp := client.InputService14TestCaseOperation2Request(params) 2608// 2609// err := req.Send() 2610// if err == nil { // resp is now filled 2611// fmt.Println(resp) 2612// } 2613func (c *InputService14ProtocolTest) InputService14TestCaseOperation2Request(input *InputService14TestShapeInputService14TestCaseOperation2Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation2Output) { 2614 op := &request.Operation{ 2615 Name: opInputService14TestCaseOperation2, 2616 HTTPMethod: "POST", 2617 HTTPPath: "/", 2618 } 2619 2620 if input == nil { 2621 input = &InputService14TestShapeInputService14TestCaseOperation2Input{} 2622 } 2623 2624 output = &InputService14TestShapeInputService14TestCaseOperation2Output{} 2625 req = c.newRequest(op, input, output) 2626 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2627 return 2628} 2629 2630// InputService14TestCaseOperation2 API operation for . 2631// 2632// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2633// with awserr.Error's Code and Message methods to get detailed information about 2634// the error. 2635// 2636// See the AWS API reference guide for 's 2637// API operation InputService14TestCaseOperation2 for usage and error information. 2638func (c *InputService14ProtocolTest) InputService14TestCaseOperation2(input *InputService14TestShapeInputService14TestCaseOperation2Input) (*InputService14TestShapeInputService14TestCaseOperation2Output, error) { 2639 req, out := c.InputService14TestCaseOperation2Request(input) 2640 return out, req.Send() 2641} 2642 2643// InputService14TestCaseOperation2WithContext is the same as InputService14TestCaseOperation2 with the addition of 2644// the ability to pass a context and additional request options. 2645// 2646// See InputService14TestCaseOperation2 for details on how to use this API operation. 2647// 2648// The context must be non-nil and will be used for request cancellation. If 2649// the context is nil a panic will occur. In the future the SDK may create 2650// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2651// for more information on using Contexts. 2652func (c *InputService14ProtocolTest) InputService14TestCaseOperation2WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation2Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation2Output, error) { 2653 req, out := c.InputService14TestCaseOperation2Request(input) 2654 req.SetContext(ctx) 2655 req.ApplyOptions(opts...) 2656 return out, req.Send() 2657} 2658 2659type InputService14TestShapeFooShape struct { 2660 _ struct{} `locationName:"foo" type:"structure"` 2661 2662 Baz *string `locationName:"baz" type:"string"` 2663} 2664 2665// SetBaz sets the Baz field's value. 2666func (s *InputService14TestShapeFooShape) SetBaz(v string) *InputService14TestShapeFooShape { 2667 s.Baz = &v 2668 return s 2669} 2670 2671type InputService14TestShapeInputService14TestCaseOperation1Input struct { 2672 _ struct{} `type:"structure" payload:"Foo"` 2673 2674 Foo *InputService14TestShapeFooShape `locationName:"foo" type:"structure"` 2675} 2676 2677// SetFoo sets the Foo field's value. 2678func (s *InputService14TestShapeInputService14TestCaseOperation1Input) SetFoo(v *InputService14TestShapeFooShape) *InputService14TestShapeInputService14TestCaseOperation1Input { 2679 s.Foo = v 2680 return s 2681} 2682 2683type InputService14TestShapeInputService14TestCaseOperation1Output struct { 2684 _ struct{} `type:"structure"` 2685} 2686 2687type InputService14TestShapeInputService14TestCaseOperation2Input struct { 2688 _ struct{} `type:"structure" payload:"Foo"` 2689 2690 Foo *InputService14TestShapeFooShape `locationName:"foo" type:"structure"` 2691} 2692 2693// SetFoo sets the Foo field's value. 2694func (s *InputService14TestShapeInputService14TestCaseOperation2Input) SetFoo(v *InputService14TestShapeFooShape) *InputService14TestShapeInputService14TestCaseOperation2Input { 2695 s.Foo = v 2696 return s 2697} 2698 2699type InputService14TestShapeInputService14TestCaseOperation2Output struct { 2700 _ struct{} `type:"structure"` 2701} 2702 2703// InputService15ProtocolTest provides the API operation methods for making requests to 2704// . See this package's package overview docs 2705// for details on the service. 2706// 2707// InputService15ProtocolTest methods are safe to use concurrently. It is not safe to 2708// modify mutate any of the struct's properties though. 2709type InputService15ProtocolTest struct { 2710 *client.Client 2711} 2712 2713// New creates a new instance of the InputService15ProtocolTest client with a session. 2714// If additional configuration is needed for the client instance use the optional 2715// aws.Config parameter to add your extra config. 2716// 2717// Example: 2718// mySession := session.Must(session.NewSession()) 2719// 2720// // Create a InputService15ProtocolTest client from just a session. 2721// svc := inputservice15protocoltest.New(mySession) 2722// 2723// // Create a InputService15ProtocolTest client with additional configuration 2724// svc := inputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2725func NewInputService15ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService15ProtocolTest { 2726 c := p.ClientConfig("inputservice15protocoltest", cfgs...) 2727 return newInputService15ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 2728} 2729 2730// newClient creates, initializes and returns a new service client instance. 2731func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService15ProtocolTest { 2732 svc := &InputService15ProtocolTest{ 2733 Client: client.New( 2734 cfg, 2735 metadata.ClientInfo{ 2736 ServiceName: "InputService15ProtocolTest", 2737 ServiceID: "InputService15ProtocolTest", 2738 SigningName: signingName, 2739 SigningRegion: signingRegion, 2740 PartitionID: partitionID, 2741 Endpoint: endpoint, 2742 APIVersion: "2014-01-01", 2743 }, 2744 handlers, 2745 ), 2746 } 2747 2748 // Handlers 2749 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2750 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 2751 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 2752 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 2753 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 2754 2755 return svc 2756} 2757 2758// newRequest creates a new request for a InputService15ProtocolTest operation and runs any 2759// custom request initialization. 2760func (c *InputService15ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2761 req := c.NewRequest(op, params, data) 2762 2763 return req 2764} 2765 2766const opInputService15TestCaseOperation1 = "OperationName" 2767 2768// InputService15TestCaseOperation1Request generates a "aws/request.Request" representing the 2769// client's request for the InputService15TestCaseOperation1 operation. The "output" return 2770// value will be populated with the request's response once the request completes 2771// successfully. 2772// 2773// Use "Send" method on the returned Request to send the API call to the service. 2774// the "output" return value is not valid until after Send returns without error. 2775// 2776// See InputService15TestCaseOperation1 for more information on using the InputService15TestCaseOperation1 2777// API call, and error handling. 2778// 2779// This method is useful when you want to inject custom logic or configuration 2780// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2781// 2782// 2783// // Example sending a request using the InputService15TestCaseOperation1Request method. 2784// req, resp := client.InputService15TestCaseOperation1Request(params) 2785// 2786// err := req.Send() 2787// if err == nil { // resp is now filled 2788// fmt.Println(resp) 2789// } 2790func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputService15TestCaseOperation1Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) { 2791 op := &request.Operation{ 2792 Name: opInputService15TestCaseOperation1, 2793 HTTPMethod: "POST", 2794 HTTPPath: "/path", 2795 } 2796 2797 if input == nil { 2798 input = &InputService15TestShapeInputService15TestCaseOperation1Input{} 2799 } 2800 2801 output = &InputService15TestShapeInputService15TestCaseOperation1Output{} 2802 req = c.newRequest(op, input, output) 2803 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2804 return 2805} 2806 2807// InputService15TestCaseOperation1 API operation for . 2808// 2809// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2810// with awserr.Error's Code and Message methods to get detailed information about 2811// the error. 2812// 2813// See the AWS API reference guide for 's 2814// API operation InputService15TestCaseOperation1 for usage and error information. 2815func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputService15TestCaseOperation1Input) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2816 req, out := c.InputService15TestCaseOperation1Request(input) 2817 return out, req.Send() 2818} 2819 2820// InputService15TestCaseOperation1WithContext is the same as InputService15TestCaseOperation1 with the addition of 2821// the ability to pass a context and additional request options. 2822// 2823// See InputService15TestCaseOperation1 for details on how to use this API operation. 2824// 2825// The context must be non-nil and will be used for request cancellation. If 2826// the context is nil a panic will occur. In the future the SDK may create 2827// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2828// for more information on using Contexts. 2829func (c *InputService15ProtocolTest) InputService15TestCaseOperation1WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation1Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2830 req, out := c.InputService15TestCaseOperation1Request(input) 2831 req.SetContext(ctx) 2832 req.ApplyOptions(opts...) 2833 return out, req.Send() 2834} 2835 2836const opInputService15TestCaseOperation2 = "OperationName" 2837 2838// InputService15TestCaseOperation2Request generates a "aws/request.Request" representing the 2839// client's request for the InputService15TestCaseOperation2 operation. The "output" return 2840// value will be populated with the request's response once the request completes 2841// successfully. 2842// 2843// Use "Send" method on the returned Request to send the API call to the service. 2844// the "output" return value is not valid until after Send returns without error. 2845// 2846// See InputService15TestCaseOperation2 for more information on using the InputService15TestCaseOperation2 2847// API call, and error handling. 2848// 2849// This method is useful when you want to inject custom logic or configuration 2850// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2851// 2852// 2853// // Example sending a request using the InputService15TestCaseOperation2Request method. 2854// req, resp := client.InputService15TestCaseOperation2Request(params) 2855// 2856// err := req.Send() 2857// if err == nil { // resp is now filled 2858// fmt.Println(resp) 2859// } 2860func (c *InputService15ProtocolTest) InputService15TestCaseOperation2Request(input *InputService15TestShapeInputService15TestCaseOperation2Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation2Output) { 2861 op := &request.Operation{ 2862 Name: opInputService15TestCaseOperation2, 2863 HTTPMethod: "POST", 2864 HTTPPath: "/path?abc=mno", 2865 } 2866 2867 if input == nil { 2868 input = &InputService15TestShapeInputService15TestCaseOperation2Input{} 2869 } 2870 2871 output = &InputService15TestShapeInputService15TestCaseOperation2Output{} 2872 req = c.newRequest(op, input, output) 2873 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2874 return 2875} 2876 2877// InputService15TestCaseOperation2 API operation for . 2878// 2879// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2880// with awserr.Error's Code and Message methods to get detailed information about 2881// the error. 2882// 2883// See the AWS API reference guide for 's 2884// API operation InputService15TestCaseOperation2 for usage and error information. 2885func (c *InputService15ProtocolTest) InputService15TestCaseOperation2(input *InputService15TestShapeInputService15TestCaseOperation2Input) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 2886 req, out := c.InputService15TestCaseOperation2Request(input) 2887 return out, req.Send() 2888} 2889 2890// InputService15TestCaseOperation2WithContext is the same as InputService15TestCaseOperation2 with the addition of 2891// the ability to pass a context and additional request options. 2892// 2893// See InputService15TestCaseOperation2 for details on how to use this API operation. 2894// 2895// The context must be non-nil and will be used for request cancellation. If 2896// the context is nil a panic will occur. In the future the SDK may create 2897// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2898// for more information on using Contexts. 2899func (c *InputService15ProtocolTest) InputService15TestCaseOperation2WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation2Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 2900 req, out := c.InputService15TestCaseOperation2Request(input) 2901 req.SetContext(ctx) 2902 req.ApplyOptions(opts...) 2903 return out, req.Send() 2904} 2905 2906type InputService15TestShapeInputService15TestCaseOperation1Input struct { 2907 _ struct{} `type:"structure"` 2908 2909 Foo *string `location:"querystring" locationName:"param-name" type:"string"` 2910} 2911 2912// SetFoo sets the Foo field's value. 2913func (s *InputService15TestShapeInputService15TestCaseOperation1Input) SetFoo(v string) *InputService15TestShapeInputService15TestCaseOperation1Input { 2914 s.Foo = &v 2915 return s 2916} 2917 2918type InputService15TestShapeInputService15TestCaseOperation1Output struct { 2919 _ struct{} `type:"structure"` 2920} 2921 2922type InputService15TestShapeInputService15TestCaseOperation2Input struct { 2923 _ struct{} `type:"structure"` 2924 2925 Foo *string `location:"querystring" locationName:"param-name" type:"string"` 2926} 2927 2928// SetFoo sets the Foo field's value. 2929func (s *InputService15TestShapeInputService15TestCaseOperation2Input) SetFoo(v string) *InputService15TestShapeInputService15TestCaseOperation2Input { 2930 s.Foo = &v 2931 return s 2932} 2933 2934type InputService15TestShapeInputService15TestCaseOperation2Output struct { 2935 _ struct{} `type:"structure"` 2936} 2937 2938// InputService16ProtocolTest provides the API operation methods for making requests to 2939// . See this package's package overview docs 2940// for details on the service. 2941// 2942// InputService16ProtocolTest methods are safe to use concurrently. It is not safe to 2943// modify mutate any of the struct's properties though. 2944type InputService16ProtocolTest struct { 2945 *client.Client 2946} 2947 2948// New creates a new instance of the InputService16ProtocolTest client with a session. 2949// If additional configuration is needed for the client instance use the optional 2950// aws.Config parameter to add your extra config. 2951// 2952// Example: 2953// mySession := session.Must(session.NewSession()) 2954// 2955// // Create a InputService16ProtocolTest client from just a session. 2956// svc := inputservice16protocoltest.New(mySession) 2957// 2958// // Create a InputService16ProtocolTest client with additional configuration 2959// svc := inputservice16protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2960func NewInputService16ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService16ProtocolTest { 2961 c := p.ClientConfig("inputservice16protocoltest", cfgs...) 2962 return newInputService16ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 2963} 2964 2965// newClient creates, initializes and returns a new service client instance. 2966func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService16ProtocolTest { 2967 svc := &InputService16ProtocolTest{ 2968 Client: client.New( 2969 cfg, 2970 metadata.ClientInfo{ 2971 ServiceName: "InputService16ProtocolTest", 2972 ServiceID: "InputService16ProtocolTest", 2973 SigningName: signingName, 2974 SigningRegion: signingRegion, 2975 PartitionID: partitionID, 2976 Endpoint: endpoint, 2977 APIVersion: "2014-01-01", 2978 }, 2979 handlers, 2980 ), 2981 } 2982 2983 // Handlers 2984 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2985 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 2986 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 2987 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 2988 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 2989 2990 return svc 2991} 2992 2993// newRequest creates a new request for a InputService16ProtocolTest operation and runs any 2994// custom request initialization. 2995func (c *InputService16ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2996 req := c.NewRequest(op, params, data) 2997 2998 return req 2999} 3000 3001const opInputService16TestCaseOperation1 = "OperationName" 3002 3003// InputService16TestCaseOperation1Request generates a "aws/request.Request" representing the 3004// client's request for the InputService16TestCaseOperation1 operation. The "output" return 3005// value will be populated with the request's response once the request completes 3006// successfully. 3007// 3008// Use "Send" method on the returned Request to send the API call to the service. 3009// the "output" return value is not valid until after Send returns without error. 3010// 3011// See InputService16TestCaseOperation1 for more information on using the InputService16TestCaseOperation1 3012// API call, and error handling. 3013// 3014// This method is useful when you want to inject custom logic or configuration 3015// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3016// 3017// 3018// // Example sending a request using the InputService16TestCaseOperation1Request method. 3019// req, resp := client.InputService16TestCaseOperation1Request(params) 3020// 3021// err := req.Send() 3022// if err == nil { // resp is now filled 3023// fmt.Println(resp) 3024// } 3025func (c *InputService16ProtocolTest) InputService16TestCaseOperation1Request(input *InputService16TestShapeInputService16TestCaseOperation1Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation1Output) { 3026 op := &request.Operation{ 3027 Name: opInputService16TestCaseOperation1, 3028 HTTPMethod: "POST", 3029 HTTPPath: "/path", 3030 } 3031 3032 if input == nil { 3033 input = &InputService16TestShapeInputService16TestCaseOperation1Input{} 3034 } 3035 3036 output = &InputService16TestShapeInputService16TestCaseOperation1Output{} 3037 req = c.newRequest(op, input, output) 3038 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3039 return 3040} 3041 3042// InputService16TestCaseOperation1 API operation for . 3043// 3044// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3045// with awserr.Error's Code and Message methods to get detailed information about 3046// the error. 3047// 3048// See the AWS API reference guide for 's 3049// API operation InputService16TestCaseOperation1 for usage and error information. 3050func (c *InputService16ProtocolTest) InputService16TestCaseOperation1(input *InputService16TestShapeInputService16TestCaseOperation1Input) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 3051 req, out := c.InputService16TestCaseOperation1Request(input) 3052 return out, req.Send() 3053} 3054 3055// InputService16TestCaseOperation1WithContext is the same as InputService16TestCaseOperation1 with the addition of 3056// the ability to pass a context and additional request options. 3057// 3058// See InputService16TestCaseOperation1 for details on how to use this API operation. 3059// 3060// The context must be non-nil and will be used for request cancellation. If 3061// the context is nil a panic will occur. In the future the SDK may create 3062// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3063// for more information on using Contexts. 3064func (c *InputService16ProtocolTest) InputService16TestCaseOperation1WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation1Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 3065 req, out := c.InputService16TestCaseOperation1Request(input) 3066 req.SetContext(ctx) 3067 req.ApplyOptions(opts...) 3068 return out, req.Send() 3069} 3070 3071const opInputService16TestCaseOperation2 = "OperationName" 3072 3073// InputService16TestCaseOperation2Request generates a "aws/request.Request" representing the 3074// client's request for the InputService16TestCaseOperation2 operation. The "output" return 3075// value will be populated with the request's response once the request completes 3076// successfully. 3077// 3078// Use "Send" method on the returned Request to send the API call to the service. 3079// the "output" return value is not valid until after Send returns without error. 3080// 3081// See InputService16TestCaseOperation2 for more information on using the InputService16TestCaseOperation2 3082// API call, and error handling. 3083// 3084// This method is useful when you want to inject custom logic or configuration 3085// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3086// 3087// 3088// // Example sending a request using the InputService16TestCaseOperation2Request method. 3089// req, resp := client.InputService16TestCaseOperation2Request(params) 3090// 3091// err := req.Send() 3092// if err == nil { // resp is now filled 3093// fmt.Println(resp) 3094// } 3095func (c *InputService16ProtocolTest) InputService16TestCaseOperation2Request(input *InputService16TestShapeInputService16TestCaseOperation2Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation2Output) { 3096 op := &request.Operation{ 3097 Name: opInputService16TestCaseOperation2, 3098 HTTPMethod: "POST", 3099 HTTPPath: "/path", 3100 } 3101 3102 if input == nil { 3103 input = &InputService16TestShapeInputService16TestCaseOperation2Input{} 3104 } 3105 3106 output = &InputService16TestShapeInputService16TestCaseOperation2Output{} 3107 req = c.newRequest(op, input, output) 3108 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3109 return 3110} 3111 3112// InputService16TestCaseOperation2 API operation for . 3113// 3114// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3115// with awserr.Error's Code and Message methods to get detailed information about 3116// the error. 3117// 3118// See the AWS API reference guide for 's 3119// API operation InputService16TestCaseOperation2 for usage and error information. 3120func (c *InputService16ProtocolTest) InputService16TestCaseOperation2(input *InputService16TestShapeInputService16TestCaseOperation2Input) (*InputService16TestShapeInputService16TestCaseOperation2Output, error) { 3121 req, out := c.InputService16TestCaseOperation2Request(input) 3122 return out, req.Send() 3123} 3124 3125// InputService16TestCaseOperation2WithContext is the same as InputService16TestCaseOperation2 with the addition of 3126// the ability to pass a context and additional request options. 3127// 3128// See InputService16TestCaseOperation2 for details on how to use this API operation. 3129// 3130// The context must be non-nil and will be used for request cancellation. If 3131// the context is nil a panic will occur. In the future the SDK may create 3132// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3133// for more information on using Contexts. 3134func (c *InputService16ProtocolTest) InputService16TestCaseOperation2WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation2Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation2Output, error) { 3135 req, out := c.InputService16TestCaseOperation2Request(input) 3136 req.SetContext(ctx) 3137 req.ApplyOptions(opts...) 3138 return out, req.Send() 3139} 3140 3141const opInputService16TestCaseOperation3 = "OperationName" 3142 3143// InputService16TestCaseOperation3Request generates a "aws/request.Request" representing the 3144// client's request for the InputService16TestCaseOperation3 operation. The "output" return 3145// value will be populated with the request's response once the request completes 3146// successfully. 3147// 3148// Use "Send" method on the returned Request to send the API call to the service. 3149// the "output" return value is not valid until after Send returns without error. 3150// 3151// See InputService16TestCaseOperation3 for more information on using the InputService16TestCaseOperation3 3152// API call, and error handling. 3153// 3154// This method is useful when you want to inject custom logic or configuration 3155// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3156// 3157// 3158// // Example sending a request using the InputService16TestCaseOperation3Request method. 3159// req, resp := client.InputService16TestCaseOperation3Request(params) 3160// 3161// err := req.Send() 3162// if err == nil { // resp is now filled 3163// fmt.Println(resp) 3164// } 3165func (c *InputService16ProtocolTest) InputService16TestCaseOperation3Request(input *InputService16TestShapeInputService16TestCaseOperation3Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation3Output) { 3166 op := &request.Operation{ 3167 Name: opInputService16TestCaseOperation3, 3168 HTTPMethod: "POST", 3169 HTTPPath: "/path", 3170 } 3171 3172 if input == nil { 3173 input = &InputService16TestShapeInputService16TestCaseOperation3Input{} 3174 } 3175 3176 output = &InputService16TestShapeInputService16TestCaseOperation3Output{} 3177 req = c.newRequest(op, input, output) 3178 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3179 return 3180} 3181 3182// InputService16TestCaseOperation3 API operation for . 3183// 3184// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3185// with awserr.Error's Code and Message methods to get detailed information about 3186// the error. 3187// 3188// See the AWS API reference guide for 's 3189// API operation InputService16TestCaseOperation3 for usage and error information. 3190func (c *InputService16ProtocolTest) InputService16TestCaseOperation3(input *InputService16TestShapeInputService16TestCaseOperation3Input) (*InputService16TestShapeInputService16TestCaseOperation3Output, error) { 3191 req, out := c.InputService16TestCaseOperation3Request(input) 3192 return out, req.Send() 3193} 3194 3195// InputService16TestCaseOperation3WithContext is the same as InputService16TestCaseOperation3 with the addition of 3196// the ability to pass a context and additional request options. 3197// 3198// See InputService16TestCaseOperation3 for details on how to use this API operation. 3199// 3200// The context must be non-nil and will be used for request cancellation. If 3201// the context is nil a panic will occur. In the future the SDK may create 3202// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3203// for more information on using Contexts. 3204func (c *InputService16ProtocolTest) InputService16TestCaseOperation3WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation3Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation3Output, error) { 3205 req, out := c.InputService16TestCaseOperation3Request(input) 3206 req.SetContext(ctx) 3207 req.ApplyOptions(opts...) 3208 return out, req.Send() 3209} 3210 3211const opInputService16TestCaseOperation4 = "OperationName" 3212 3213// InputService16TestCaseOperation4Request generates a "aws/request.Request" representing the 3214// client's request for the InputService16TestCaseOperation4 operation. The "output" return 3215// value will be populated with the request's response once the request completes 3216// successfully. 3217// 3218// Use "Send" method on the returned Request to send the API call to the service. 3219// the "output" return value is not valid until after Send returns without error. 3220// 3221// See InputService16TestCaseOperation4 for more information on using the InputService16TestCaseOperation4 3222// API call, and error handling. 3223// 3224// This method is useful when you want to inject custom logic or configuration 3225// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3226// 3227// 3228// // Example sending a request using the InputService16TestCaseOperation4Request method. 3229// req, resp := client.InputService16TestCaseOperation4Request(params) 3230// 3231// err := req.Send() 3232// if err == nil { // resp is now filled 3233// fmt.Println(resp) 3234// } 3235func (c *InputService16ProtocolTest) InputService16TestCaseOperation4Request(input *InputService16TestShapeInputService16TestCaseOperation4Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation4Output) { 3236 op := &request.Operation{ 3237 Name: opInputService16TestCaseOperation4, 3238 HTTPMethod: "POST", 3239 HTTPPath: "/path", 3240 } 3241 3242 if input == nil { 3243 input = &InputService16TestShapeInputService16TestCaseOperation4Input{} 3244 } 3245 3246 output = &InputService16TestShapeInputService16TestCaseOperation4Output{} 3247 req = c.newRequest(op, input, output) 3248 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3249 return 3250} 3251 3252// InputService16TestCaseOperation4 API operation for . 3253// 3254// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3255// with awserr.Error's Code and Message methods to get detailed information about 3256// the error. 3257// 3258// See the AWS API reference guide for 's 3259// API operation InputService16TestCaseOperation4 for usage and error information. 3260func (c *InputService16ProtocolTest) InputService16TestCaseOperation4(input *InputService16TestShapeInputService16TestCaseOperation4Input) (*InputService16TestShapeInputService16TestCaseOperation4Output, error) { 3261 req, out := c.InputService16TestCaseOperation4Request(input) 3262 return out, req.Send() 3263} 3264 3265// InputService16TestCaseOperation4WithContext is the same as InputService16TestCaseOperation4 with the addition of 3266// the ability to pass a context and additional request options. 3267// 3268// See InputService16TestCaseOperation4 for details on how to use this API operation. 3269// 3270// The context must be non-nil and will be used for request cancellation. If 3271// the context is nil a panic will occur. In the future the SDK may create 3272// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3273// for more information on using Contexts. 3274func (c *InputService16ProtocolTest) InputService16TestCaseOperation4WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation4Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation4Output, error) { 3275 req, out := c.InputService16TestCaseOperation4Request(input) 3276 req.SetContext(ctx) 3277 req.ApplyOptions(opts...) 3278 return out, req.Send() 3279} 3280 3281const opInputService16TestCaseOperation5 = "OperationName" 3282 3283// InputService16TestCaseOperation5Request generates a "aws/request.Request" representing the 3284// client's request for the InputService16TestCaseOperation5 operation. The "output" return 3285// value will be populated with the request's response once the request completes 3286// successfully. 3287// 3288// Use "Send" method on the returned Request to send the API call to the service. 3289// the "output" return value is not valid until after Send returns without error. 3290// 3291// See InputService16TestCaseOperation5 for more information on using the InputService16TestCaseOperation5 3292// API call, and error handling. 3293// 3294// This method is useful when you want to inject custom logic or configuration 3295// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3296// 3297// 3298// // Example sending a request using the InputService16TestCaseOperation5Request method. 3299// req, resp := client.InputService16TestCaseOperation5Request(params) 3300// 3301// err := req.Send() 3302// if err == nil { // resp is now filled 3303// fmt.Println(resp) 3304// } 3305func (c *InputService16ProtocolTest) InputService16TestCaseOperation5Request(input *InputService16TestShapeInputService16TestCaseOperation5Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation5Output) { 3306 op := &request.Operation{ 3307 Name: opInputService16TestCaseOperation5, 3308 HTTPMethod: "POST", 3309 HTTPPath: "/path", 3310 } 3311 3312 if input == nil { 3313 input = &InputService16TestShapeInputService16TestCaseOperation5Input{} 3314 } 3315 3316 output = &InputService16TestShapeInputService16TestCaseOperation5Output{} 3317 req = c.newRequest(op, input, output) 3318 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3319 return 3320} 3321 3322// InputService16TestCaseOperation5 API operation for . 3323// 3324// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3325// with awserr.Error's Code and Message methods to get detailed information about 3326// the error. 3327// 3328// See the AWS API reference guide for 's 3329// API operation InputService16TestCaseOperation5 for usage and error information. 3330func (c *InputService16ProtocolTest) InputService16TestCaseOperation5(input *InputService16TestShapeInputService16TestCaseOperation5Input) (*InputService16TestShapeInputService16TestCaseOperation5Output, error) { 3331 req, out := c.InputService16TestCaseOperation5Request(input) 3332 return out, req.Send() 3333} 3334 3335// InputService16TestCaseOperation5WithContext is the same as InputService16TestCaseOperation5 with the addition of 3336// the ability to pass a context and additional request options. 3337// 3338// See InputService16TestCaseOperation5 for details on how to use this API operation. 3339// 3340// The context must be non-nil and will be used for request cancellation. If 3341// the context is nil a panic will occur. In the future the SDK may create 3342// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3343// for more information on using Contexts. 3344func (c *InputService16ProtocolTest) InputService16TestCaseOperation5WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation5Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation5Output, error) { 3345 req, out := c.InputService16TestCaseOperation5Request(input) 3346 req.SetContext(ctx) 3347 req.ApplyOptions(opts...) 3348 return out, req.Send() 3349} 3350 3351const opInputService16TestCaseOperation6 = "OperationName" 3352 3353// InputService16TestCaseOperation6Request generates a "aws/request.Request" representing the 3354// client's request for the InputService16TestCaseOperation6 operation. The "output" return 3355// value will be populated with the request's response once the request completes 3356// successfully. 3357// 3358// Use "Send" method on the returned Request to send the API call to the service. 3359// the "output" return value is not valid until after Send returns without error. 3360// 3361// See InputService16TestCaseOperation6 for more information on using the InputService16TestCaseOperation6 3362// API call, and error handling. 3363// 3364// This method is useful when you want to inject custom logic or configuration 3365// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3366// 3367// 3368// // Example sending a request using the InputService16TestCaseOperation6Request method. 3369// req, resp := client.InputService16TestCaseOperation6Request(params) 3370// 3371// err := req.Send() 3372// if err == nil { // resp is now filled 3373// fmt.Println(resp) 3374// } 3375func (c *InputService16ProtocolTest) InputService16TestCaseOperation6Request(input *InputService16TestShapeInputService16TestCaseOperation6Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation6Output) { 3376 op := &request.Operation{ 3377 Name: opInputService16TestCaseOperation6, 3378 HTTPMethod: "POST", 3379 HTTPPath: "/path", 3380 } 3381 3382 if input == nil { 3383 input = &InputService16TestShapeInputService16TestCaseOperation6Input{} 3384 } 3385 3386 output = &InputService16TestShapeInputService16TestCaseOperation6Output{} 3387 req = c.newRequest(op, input, output) 3388 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3389 return 3390} 3391 3392// InputService16TestCaseOperation6 API operation for . 3393// 3394// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3395// with awserr.Error's Code and Message methods to get detailed information about 3396// the error. 3397// 3398// See the AWS API reference guide for 's 3399// API operation InputService16TestCaseOperation6 for usage and error information. 3400func (c *InputService16ProtocolTest) InputService16TestCaseOperation6(input *InputService16TestShapeInputService16TestCaseOperation6Input) (*InputService16TestShapeInputService16TestCaseOperation6Output, error) { 3401 req, out := c.InputService16TestCaseOperation6Request(input) 3402 return out, req.Send() 3403} 3404 3405// InputService16TestCaseOperation6WithContext is the same as InputService16TestCaseOperation6 with the addition of 3406// the ability to pass a context and additional request options. 3407// 3408// See InputService16TestCaseOperation6 for details on how to use this API operation. 3409// 3410// The context must be non-nil and will be used for request cancellation. If 3411// the context is nil a panic will occur. In the future the SDK may create 3412// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3413// for more information on using Contexts. 3414func (c *InputService16ProtocolTest) InputService16TestCaseOperation6WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation6Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation6Output, error) { 3415 req, out := c.InputService16TestCaseOperation6Request(input) 3416 req.SetContext(ctx) 3417 req.ApplyOptions(opts...) 3418 return out, req.Send() 3419} 3420 3421type InputService16TestShapeInputService16TestCaseOperation1Input struct { 3422 _ struct{} `type:"structure"` 3423 3424 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3425} 3426 3427// SetRecursiveStruct sets the RecursiveStruct field's value. 3428func (s *InputService16TestShapeInputService16TestCaseOperation1Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation1Input { 3429 s.RecursiveStruct = v 3430 return s 3431} 3432 3433type InputService16TestShapeInputService16TestCaseOperation1Output struct { 3434 _ struct{} `type:"structure"` 3435} 3436 3437type InputService16TestShapeInputService16TestCaseOperation2Input struct { 3438 _ struct{} `type:"structure"` 3439 3440 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3441} 3442 3443// SetRecursiveStruct sets the RecursiveStruct field's value. 3444func (s *InputService16TestShapeInputService16TestCaseOperation2Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation2Input { 3445 s.RecursiveStruct = v 3446 return s 3447} 3448 3449type InputService16TestShapeInputService16TestCaseOperation2Output struct { 3450 _ struct{} `type:"structure"` 3451} 3452 3453type InputService16TestShapeInputService16TestCaseOperation3Input struct { 3454 _ struct{} `type:"structure"` 3455 3456 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3457} 3458 3459// SetRecursiveStruct sets the RecursiveStruct field's value. 3460func (s *InputService16TestShapeInputService16TestCaseOperation3Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation3Input { 3461 s.RecursiveStruct = v 3462 return s 3463} 3464 3465type InputService16TestShapeInputService16TestCaseOperation3Output struct { 3466 _ struct{} `type:"structure"` 3467} 3468 3469type InputService16TestShapeInputService16TestCaseOperation4Input struct { 3470 _ struct{} `type:"structure"` 3471 3472 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3473} 3474 3475// SetRecursiveStruct sets the RecursiveStruct field's value. 3476func (s *InputService16TestShapeInputService16TestCaseOperation4Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation4Input { 3477 s.RecursiveStruct = v 3478 return s 3479} 3480 3481type InputService16TestShapeInputService16TestCaseOperation4Output struct { 3482 _ struct{} `type:"structure"` 3483} 3484 3485type InputService16TestShapeInputService16TestCaseOperation5Input struct { 3486 _ struct{} `type:"structure"` 3487 3488 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3489} 3490 3491// SetRecursiveStruct sets the RecursiveStruct field's value. 3492func (s *InputService16TestShapeInputService16TestCaseOperation5Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation5Input { 3493 s.RecursiveStruct = v 3494 return s 3495} 3496 3497type InputService16TestShapeInputService16TestCaseOperation5Output struct { 3498 _ struct{} `type:"structure"` 3499} 3500 3501type InputService16TestShapeInputService16TestCaseOperation6Input struct { 3502 _ struct{} `type:"structure"` 3503 3504 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3505} 3506 3507// SetRecursiveStruct sets the RecursiveStruct field's value. 3508func (s *InputService16TestShapeInputService16TestCaseOperation6Input) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeInputService16TestCaseOperation6Input { 3509 s.RecursiveStruct = v 3510 return s 3511} 3512 3513type InputService16TestShapeInputService16TestCaseOperation6Output struct { 3514 _ struct{} `type:"structure"` 3515} 3516 3517type InputService16TestShapeRecursiveStructType struct { 3518 _ struct{} `type:"structure"` 3519 3520 NoRecurse *string `type:"string"` 3521 3522 RecursiveList []*InputService16TestShapeRecursiveStructType `type:"list"` 3523 3524 RecursiveMap map[string]*InputService16TestShapeRecursiveStructType `type:"map"` 3525 3526 RecursiveStruct *InputService16TestShapeRecursiveStructType `type:"structure"` 3527} 3528 3529// SetNoRecurse sets the NoRecurse field's value. 3530func (s *InputService16TestShapeRecursiveStructType) SetNoRecurse(v string) *InputService16TestShapeRecursiveStructType { 3531 s.NoRecurse = &v 3532 return s 3533} 3534 3535// SetRecursiveList sets the RecursiveList field's value. 3536func (s *InputService16TestShapeRecursiveStructType) SetRecursiveList(v []*InputService16TestShapeRecursiveStructType) *InputService16TestShapeRecursiveStructType { 3537 s.RecursiveList = v 3538 return s 3539} 3540 3541// SetRecursiveMap sets the RecursiveMap field's value. 3542func (s *InputService16TestShapeRecursiveStructType) SetRecursiveMap(v map[string]*InputService16TestShapeRecursiveStructType) *InputService16TestShapeRecursiveStructType { 3543 s.RecursiveMap = v 3544 return s 3545} 3546 3547// SetRecursiveStruct sets the RecursiveStruct field's value. 3548func (s *InputService16TestShapeRecursiveStructType) SetRecursiveStruct(v *InputService16TestShapeRecursiveStructType) *InputService16TestShapeRecursiveStructType { 3549 s.RecursiveStruct = v 3550 return s 3551} 3552 3553// InputService17ProtocolTest provides the API operation methods for making requests to 3554// . See this package's package overview docs 3555// for details on the service. 3556// 3557// InputService17ProtocolTest methods are safe to use concurrently. It is not safe to 3558// modify mutate any of the struct's properties though. 3559type InputService17ProtocolTest struct { 3560 *client.Client 3561} 3562 3563// New creates a new instance of the InputService17ProtocolTest client with a session. 3564// If additional configuration is needed for the client instance use the optional 3565// aws.Config parameter to add your extra config. 3566// 3567// Example: 3568// mySession := session.Must(session.NewSession()) 3569// 3570// // Create a InputService17ProtocolTest client from just a session. 3571// svc := inputservice17protocoltest.New(mySession) 3572// 3573// // Create a InputService17ProtocolTest client with additional configuration 3574// svc := inputservice17protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3575func NewInputService17ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService17ProtocolTest { 3576 c := p.ClientConfig("inputservice17protocoltest", cfgs...) 3577 return newInputService17ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 3578} 3579 3580// newClient creates, initializes and returns a new service client instance. 3581func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService17ProtocolTest { 3582 svc := &InputService17ProtocolTest{ 3583 Client: client.New( 3584 cfg, 3585 metadata.ClientInfo{ 3586 ServiceName: "InputService17ProtocolTest", 3587 ServiceID: "InputService17ProtocolTest", 3588 SigningName: signingName, 3589 SigningRegion: signingRegion, 3590 PartitionID: partitionID, 3591 Endpoint: endpoint, 3592 APIVersion: "2014-01-01", 3593 }, 3594 handlers, 3595 ), 3596 } 3597 3598 // Handlers 3599 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3600 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 3601 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 3602 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 3603 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 3604 3605 return svc 3606} 3607 3608// newRequest creates a new request for a InputService17ProtocolTest operation and runs any 3609// custom request initialization. 3610func (c *InputService17ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3611 req := c.NewRequest(op, params, data) 3612 3613 return req 3614} 3615 3616const opInputService17TestCaseOperation1 = "OperationName" 3617 3618// InputService17TestCaseOperation1Request generates a "aws/request.Request" representing the 3619// client's request for the InputService17TestCaseOperation1 operation. The "output" return 3620// value will be populated with the request's response once the request completes 3621// successfully. 3622// 3623// Use "Send" method on the returned Request to send the API call to the service. 3624// the "output" return value is not valid until after Send returns without error. 3625// 3626// See InputService17TestCaseOperation1 for more information on using the InputService17TestCaseOperation1 3627// API call, and error handling. 3628// 3629// This method is useful when you want to inject custom logic or configuration 3630// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3631// 3632// 3633// // Example sending a request using the InputService17TestCaseOperation1Request method. 3634// req, resp := client.InputService17TestCaseOperation1Request(params) 3635// 3636// err := req.Send() 3637// if err == nil { // resp is now filled 3638// fmt.Println(resp) 3639// } 3640func (c *InputService17ProtocolTest) InputService17TestCaseOperation1Request(input *InputService17TestShapeInputService17TestCaseOperation1Input) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation1Output) { 3641 op := &request.Operation{ 3642 Name: opInputService17TestCaseOperation1, 3643 HTTPMethod: "POST", 3644 HTTPPath: "/path", 3645 } 3646 3647 if input == nil { 3648 input = &InputService17TestShapeInputService17TestCaseOperation1Input{} 3649 } 3650 3651 output = &InputService17TestShapeInputService17TestCaseOperation1Output{} 3652 req = c.newRequest(op, input, output) 3653 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3654 return 3655} 3656 3657// InputService17TestCaseOperation1 API operation for . 3658// 3659// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3660// with awserr.Error's Code and Message methods to get detailed information about 3661// the error. 3662// 3663// See the AWS API reference guide for 's 3664// API operation InputService17TestCaseOperation1 for usage and error information. 3665func (c *InputService17ProtocolTest) InputService17TestCaseOperation1(input *InputService17TestShapeInputService17TestCaseOperation1Input) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 3666 req, out := c.InputService17TestCaseOperation1Request(input) 3667 return out, req.Send() 3668} 3669 3670// InputService17TestCaseOperation1WithContext is the same as InputService17TestCaseOperation1 with the addition of 3671// the ability to pass a context and additional request options. 3672// 3673// See InputService17TestCaseOperation1 for details on how to use this API operation. 3674// 3675// The context must be non-nil and will be used for request cancellation. If 3676// the context is nil a panic will occur. In the future the SDK may create 3677// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3678// for more information on using Contexts. 3679func (c *InputService17ProtocolTest) InputService17TestCaseOperation1WithContext(ctx aws.Context, input *InputService17TestShapeInputService17TestCaseOperation1Input, opts ...request.Option) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 3680 req, out := c.InputService17TestCaseOperation1Request(input) 3681 req.SetContext(ctx) 3682 req.ApplyOptions(opts...) 3683 return out, req.Send() 3684} 3685 3686type InputService17TestShapeInputService17TestCaseOperation1Input struct { 3687 _ struct{} `type:"structure"` 3688 3689 TimeArg *time.Time `type:"timestamp"` 3690 3691 TimeArgInHeader *time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp"` 3692 3693 TimeArgInQuery *time.Time `location:"querystring" locationName:"TimeQuery" type:"timestamp"` 3694 3695 TimeCustom *time.Time `type:"timestamp" timestampFormat:"iso8601"` 3696 3697 TimeCustomInHeader *time.Time `location:"header" locationName:"x-amz-timecustom-header" type:"timestamp" timestampFormat:"unixTimestamp"` 3698 3699 TimeCustomInQuery *time.Time `location:"querystring" locationName:"TimeCustomQuery" type:"timestamp" timestampFormat:"unixTimestamp"` 3700 3701 TimeFormat *time.Time `type:"timestamp" timestampFormat:"rfc822"` 3702 3703 TimeFormatInHeader *time.Time `location:"header" locationName:"x-amz-timeformat-header" type:"timestamp" timestampFormat:"unixTimestamp"` 3704 3705 TimeFormatInQuery *time.Time `location:"querystring" locationName:"TimeFormatQuery" type:"timestamp" timestampFormat:"unixTimestamp"` 3706} 3707 3708// SetTimeArg sets the TimeArg field's value. 3709func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3710 s.TimeArg = &v 3711 return s 3712} 3713 3714// SetTimeArgInHeader sets the TimeArgInHeader field's value. 3715func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeArgInHeader(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3716 s.TimeArgInHeader = &v 3717 return s 3718} 3719 3720// SetTimeArgInQuery sets the TimeArgInQuery field's value. 3721func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeArgInQuery(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3722 s.TimeArgInQuery = &v 3723 return s 3724} 3725 3726// SetTimeCustom sets the TimeCustom field's value. 3727func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeCustom(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3728 s.TimeCustom = &v 3729 return s 3730} 3731 3732// SetTimeCustomInHeader sets the TimeCustomInHeader field's value. 3733func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeCustomInHeader(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3734 s.TimeCustomInHeader = &v 3735 return s 3736} 3737 3738// SetTimeCustomInQuery sets the TimeCustomInQuery field's value. 3739func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeCustomInQuery(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3740 s.TimeCustomInQuery = &v 3741 return s 3742} 3743 3744// SetTimeFormat sets the TimeFormat field's value. 3745func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeFormat(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3746 s.TimeFormat = &v 3747 return s 3748} 3749 3750// SetTimeFormatInHeader sets the TimeFormatInHeader field's value. 3751func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeFormatInHeader(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3752 s.TimeFormatInHeader = &v 3753 return s 3754} 3755 3756// SetTimeFormatInQuery sets the TimeFormatInQuery field's value. 3757func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetTimeFormatInQuery(v time.Time) *InputService17TestShapeInputService17TestCaseOperation1Input { 3758 s.TimeFormatInQuery = &v 3759 return s 3760} 3761 3762type InputService17TestShapeInputService17TestCaseOperation1Output struct { 3763 _ struct{} `type:"structure"` 3764} 3765 3766// InputService18ProtocolTest provides the API operation methods for making requests to 3767// . See this package's package overview docs 3768// for details on the service. 3769// 3770// InputService18ProtocolTest methods are safe to use concurrently. It is not safe to 3771// modify mutate any of the struct's properties though. 3772type InputService18ProtocolTest struct { 3773 *client.Client 3774} 3775 3776// New creates a new instance of the InputService18ProtocolTest client with a session. 3777// If additional configuration is needed for the client instance use the optional 3778// aws.Config parameter to add your extra config. 3779// 3780// Example: 3781// mySession := session.Must(session.NewSession()) 3782// 3783// // Create a InputService18ProtocolTest client from just a session. 3784// svc := inputservice18protocoltest.New(mySession) 3785// 3786// // Create a InputService18ProtocolTest client with additional configuration 3787// svc := inputservice18protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3788func NewInputService18ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService18ProtocolTest { 3789 c := p.ClientConfig("inputservice18protocoltest", cfgs...) 3790 return newInputService18ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 3791} 3792 3793// newClient creates, initializes and returns a new service client instance. 3794func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService18ProtocolTest { 3795 svc := &InputService18ProtocolTest{ 3796 Client: client.New( 3797 cfg, 3798 metadata.ClientInfo{ 3799 ServiceName: "InputService18ProtocolTest", 3800 ServiceID: "InputService18ProtocolTest", 3801 SigningName: signingName, 3802 SigningRegion: signingRegion, 3803 PartitionID: partitionID, 3804 Endpoint: endpoint, 3805 APIVersion: "2014-01-01", 3806 }, 3807 handlers, 3808 ), 3809 } 3810 3811 // Handlers 3812 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3813 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 3814 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 3815 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 3816 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 3817 3818 return svc 3819} 3820 3821// newRequest creates a new request for a InputService18ProtocolTest operation and runs any 3822// custom request initialization. 3823func (c *InputService18ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3824 req := c.NewRequest(op, params, data) 3825 3826 return req 3827} 3828 3829const opInputService18TestCaseOperation1 = "OperationName" 3830 3831// InputService18TestCaseOperation1Request generates a "aws/request.Request" representing the 3832// client's request for the InputService18TestCaseOperation1 operation. The "output" return 3833// value will be populated with the request's response once the request completes 3834// successfully. 3835// 3836// Use "Send" method on the returned Request to send the API call to the service. 3837// the "output" return value is not valid until after Send returns without error. 3838// 3839// See InputService18TestCaseOperation1 for more information on using the InputService18TestCaseOperation1 3840// API call, and error handling. 3841// 3842// This method is useful when you want to inject custom logic or configuration 3843// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3844// 3845// 3846// // Example sending a request using the InputService18TestCaseOperation1Request method. 3847// req, resp := client.InputService18TestCaseOperation1Request(params) 3848// 3849// err := req.Send() 3850// if err == nil { // resp is now filled 3851// fmt.Println(resp) 3852// } 3853func (c *InputService18ProtocolTest) InputService18TestCaseOperation1Request(input *InputService18TestShapeInputService18TestCaseOperation1Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation1Output) { 3854 op := &request.Operation{ 3855 Name: opInputService18TestCaseOperation1, 3856 HTTPMethod: "POST", 3857 HTTPPath: "/path", 3858 } 3859 3860 if input == nil { 3861 input = &InputService18TestShapeInputService18TestCaseOperation1Input{} 3862 } 3863 3864 output = &InputService18TestShapeInputService18TestCaseOperation1Output{} 3865 req = c.newRequest(op, input, output) 3866 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3867 return 3868} 3869 3870// InputService18TestCaseOperation1 API operation for . 3871// 3872// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3873// with awserr.Error's Code and Message methods to get detailed information about 3874// the error. 3875// 3876// See the AWS API reference guide for 's 3877// API operation InputService18TestCaseOperation1 for usage and error information. 3878func (c *InputService18ProtocolTest) InputService18TestCaseOperation1(input *InputService18TestShapeInputService18TestCaseOperation1Input) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3879 req, out := c.InputService18TestCaseOperation1Request(input) 3880 return out, req.Send() 3881} 3882 3883// InputService18TestCaseOperation1WithContext is the same as InputService18TestCaseOperation1 with the addition of 3884// the ability to pass a context and additional request options. 3885// 3886// See InputService18TestCaseOperation1 for details on how to use this API operation. 3887// 3888// The context must be non-nil and will be used for request cancellation. If 3889// the context is nil a panic will occur. In the future the SDK may create 3890// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3891// for more information on using Contexts. 3892func (c *InputService18ProtocolTest) InputService18TestCaseOperation1WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation1Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3893 req, out := c.InputService18TestCaseOperation1Request(input) 3894 req.SetContext(ctx) 3895 req.ApplyOptions(opts...) 3896 return out, req.Send() 3897} 3898 3899type InputService18TestShapeInputService18TestCaseOperation1Input struct { 3900 _ struct{} `type:"structure"` 3901 3902 TimeArg *time.Time `locationName:"timestamp_location" type:"timestamp"` 3903} 3904 3905// SetTimeArg sets the TimeArg field's value. 3906func (s *InputService18TestShapeInputService18TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService18TestShapeInputService18TestCaseOperation1Input { 3907 s.TimeArg = &v 3908 return s 3909} 3910 3911type InputService18TestShapeInputService18TestCaseOperation1Output struct { 3912 _ struct{} `type:"structure"` 3913} 3914 3915// InputService19ProtocolTest provides the API operation methods for making requests to 3916// . See this package's package overview docs 3917// for details on the service. 3918// 3919// InputService19ProtocolTest methods are safe to use concurrently. It is not safe to 3920// modify mutate any of the struct's properties though. 3921type InputService19ProtocolTest struct { 3922 *client.Client 3923} 3924 3925// New creates a new instance of the InputService19ProtocolTest client with a session. 3926// If additional configuration is needed for the client instance use the optional 3927// aws.Config parameter to add your extra config. 3928// 3929// Example: 3930// mySession := session.Must(session.NewSession()) 3931// 3932// // Create a InputService19ProtocolTest client from just a session. 3933// svc := inputservice19protocoltest.New(mySession) 3934// 3935// // Create a InputService19ProtocolTest client with additional configuration 3936// svc := inputservice19protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3937func NewInputService19ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService19ProtocolTest { 3938 c := p.ClientConfig("inputservice19protocoltest", cfgs...) 3939 return newInputService19ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 3940} 3941 3942// newClient creates, initializes and returns a new service client instance. 3943func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService19ProtocolTest { 3944 svc := &InputService19ProtocolTest{ 3945 Client: client.New( 3946 cfg, 3947 metadata.ClientInfo{ 3948 ServiceName: "InputService19ProtocolTest", 3949 ServiceID: "InputService19ProtocolTest", 3950 SigningName: signingName, 3951 SigningRegion: signingRegion, 3952 PartitionID: partitionID, 3953 Endpoint: endpoint, 3954 APIVersion: "2014-01-01", 3955 }, 3956 handlers, 3957 ), 3958 } 3959 3960 // Handlers 3961 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3962 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 3963 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 3964 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 3965 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 3966 3967 return svc 3968} 3969 3970// newRequest creates a new request for a InputService19ProtocolTest operation and runs any 3971// custom request initialization. 3972func (c *InputService19ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3973 req := c.NewRequest(op, params, data) 3974 3975 return req 3976} 3977 3978const opInputService19TestCaseOperation1 = "OperationName" 3979 3980// InputService19TestCaseOperation1Request generates a "aws/request.Request" representing the 3981// client's request for the InputService19TestCaseOperation1 operation. The "output" return 3982// value will be populated with the request's response once the request completes 3983// successfully. 3984// 3985// Use "Send" method on the returned Request to send the API call to the service. 3986// the "output" return value is not valid until after Send returns without error. 3987// 3988// See InputService19TestCaseOperation1 for more information on using the InputService19TestCaseOperation1 3989// API call, and error handling. 3990// 3991// This method is useful when you want to inject custom logic or configuration 3992// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3993// 3994// 3995// // Example sending a request using the InputService19TestCaseOperation1Request method. 3996// req, resp := client.InputService19TestCaseOperation1Request(params) 3997// 3998// err := req.Send() 3999// if err == nil { // resp is now filled 4000// fmt.Println(resp) 4001// } 4002func (c *InputService19ProtocolTest) InputService19TestCaseOperation1Request(input *InputService19TestShapeInputService19TestCaseOperation1Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation1Output) { 4003 op := &request.Operation{ 4004 Name: opInputService19TestCaseOperation1, 4005 HTTPMethod: "POST", 4006 HTTPPath: "/", 4007 } 4008 4009 if input == nil { 4010 input = &InputService19TestShapeInputService19TestCaseOperation1Input{} 4011 } 4012 4013 output = &InputService19TestShapeInputService19TestCaseOperation1Output{} 4014 req = c.newRequest(op, input, output) 4015 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4016 return 4017} 4018 4019// InputService19TestCaseOperation1 API operation for . 4020// 4021// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4022// with awserr.Error's Code and Message methods to get detailed information about 4023// the error. 4024// 4025// See the AWS API reference guide for 's 4026// API operation InputService19TestCaseOperation1 for usage and error information. 4027func (c *InputService19ProtocolTest) InputService19TestCaseOperation1(input *InputService19TestShapeInputService19TestCaseOperation1Input) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 4028 req, out := c.InputService19TestCaseOperation1Request(input) 4029 return out, req.Send() 4030} 4031 4032// InputService19TestCaseOperation1WithContext is the same as InputService19TestCaseOperation1 with the addition of 4033// the ability to pass a context and additional request options. 4034// 4035// See InputService19TestCaseOperation1 for details on how to use this API operation. 4036// 4037// The context must be non-nil and will be used for request cancellation. If 4038// the context is nil a panic will occur. In the future the SDK may create 4039// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4040// for more information on using Contexts. 4041func (c *InputService19ProtocolTest) InputService19TestCaseOperation1WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation1Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 4042 req, out := c.InputService19TestCaseOperation1Request(input) 4043 req.SetContext(ctx) 4044 req.ApplyOptions(opts...) 4045 return out, req.Send() 4046} 4047 4048type InputService19TestShapeInputService19TestCaseOperation1Input struct { 4049 _ struct{} `type:"structure" payload:"Foo"` 4050 4051 Foo *string `locationName:"foo" type:"string"` 4052} 4053 4054// SetFoo sets the Foo field's value. 4055func (s *InputService19TestShapeInputService19TestCaseOperation1Input) SetFoo(v string) *InputService19TestShapeInputService19TestCaseOperation1Input { 4056 s.Foo = &v 4057 return s 4058} 4059 4060type InputService19TestShapeInputService19TestCaseOperation1Output struct { 4061 _ struct{} `type:"structure"` 4062} 4063 4064// InputService20ProtocolTest provides the API operation methods for making requests to 4065// . See this package's package overview docs 4066// for details on the service. 4067// 4068// InputService20ProtocolTest methods are safe to use concurrently. It is not safe to 4069// modify mutate any of the struct's properties though. 4070type InputService20ProtocolTest struct { 4071 *client.Client 4072} 4073 4074// New creates a new instance of the InputService20ProtocolTest client with a session. 4075// If additional configuration is needed for the client instance use the optional 4076// aws.Config parameter to add your extra config. 4077// 4078// Example: 4079// mySession := session.Must(session.NewSession()) 4080// 4081// // Create a InputService20ProtocolTest client from just a session. 4082// svc := inputservice20protocoltest.New(mySession) 4083// 4084// // Create a InputService20ProtocolTest client with additional configuration 4085// svc := inputservice20protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4086func NewInputService20ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService20ProtocolTest { 4087 c := p.ClientConfig("inputservice20protocoltest", cfgs...) 4088 return newInputService20ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 4089} 4090 4091// newClient creates, initializes and returns a new service client instance. 4092func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService20ProtocolTest { 4093 svc := &InputService20ProtocolTest{ 4094 Client: client.New( 4095 cfg, 4096 metadata.ClientInfo{ 4097 ServiceName: "InputService20ProtocolTest", 4098 ServiceID: "InputService20ProtocolTest", 4099 SigningName: signingName, 4100 SigningRegion: signingRegion, 4101 PartitionID: partitionID, 4102 Endpoint: endpoint, 4103 APIVersion: "2014-01-01", 4104 }, 4105 handlers, 4106 ), 4107 } 4108 4109 // Handlers 4110 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4111 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 4112 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 4113 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 4114 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 4115 4116 return svc 4117} 4118 4119// newRequest creates a new request for a InputService20ProtocolTest operation and runs any 4120// custom request initialization. 4121func (c *InputService20ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4122 req := c.NewRequest(op, params, data) 4123 4124 return req 4125} 4126 4127const opInputService20TestCaseOperation1 = "OperationName" 4128 4129// InputService20TestCaseOperation1Request generates a "aws/request.Request" representing the 4130// client's request for the InputService20TestCaseOperation1 operation. The "output" return 4131// value will be populated with the request's response once the request completes 4132// successfully. 4133// 4134// Use "Send" method on the returned Request to send the API call to the service. 4135// the "output" return value is not valid until after Send returns without error. 4136// 4137// See InputService20TestCaseOperation1 for more information on using the InputService20TestCaseOperation1 4138// API call, and error handling. 4139// 4140// This method is useful when you want to inject custom logic or configuration 4141// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4142// 4143// 4144// // Example sending a request using the InputService20TestCaseOperation1Request method. 4145// req, resp := client.InputService20TestCaseOperation1Request(params) 4146// 4147// err := req.Send() 4148// if err == nil { // resp is now filled 4149// fmt.Println(resp) 4150// } 4151func (c *InputService20ProtocolTest) InputService20TestCaseOperation1Request(input *InputService20TestShapeInputService20TestCaseOperation1Input) (req *request.Request, output *InputService20TestShapeInputService20TestCaseOperation1Output) { 4152 op := &request.Operation{ 4153 Name: opInputService20TestCaseOperation1, 4154 HTTPMethod: "POST", 4155 HTTPPath: "/path", 4156 } 4157 4158 if input == nil { 4159 input = &InputService20TestShapeInputService20TestCaseOperation1Input{} 4160 } 4161 4162 output = &InputService20TestShapeInputService20TestCaseOperation1Output{} 4163 req = c.newRequest(op, input, output) 4164 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4165 return 4166} 4167 4168// InputService20TestCaseOperation1 API operation for . 4169// 4170// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4171// with awserr.Error's Code and Message methods to get detailed information about 4172// the error. 4173// 4174// See the AWS API reference guide for 's 4175// API operation InputService20TestCaseOperation1 for usage and error information. 4176func (c *InputService20ProtocolTest) InputService20TestCaseOperation1(input *InputService20TestShapeInputService20TestCaseOperation1Input) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 4177 req, out := c.InputService20TestCaseOperation1Request(input) 4178 return out, req.Send() 4179} 4180 4181// InputService20TestCaseOperation1WithContext is the same as InputService20TestCaseOperation1 with the addition of 4182// the ability to pass a context and additional request options. 4183// 4184// See InputService20TestCaseOperation1 for details on how to use this API operation. 4185// 4186// The context must be non-nil and will be used for request cancellation. If 4187// the context is nil a panic will occur. In the future the SDK may create 4188// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4189// for more information on using Contexts. 4190func (c *InputService20ProtocolTest) InputService20TestCaseOperation1WithContext(ctx aws.Context, input *InputService20TestShapeInputService20TestCaseOperation1Input, opts ...request.Option) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 4191 req, out := c.InputService20TestCaseOperation1Request(input) 4192 req.SetContext(ctx) 4193 req.ApplyOptions(opts...) 4194 return out, req.Send() 4195} 4196 4197const opInputService20TestCaseOperation2 = "OperationName" 4198 4199// InputService20TestCaseOperation2Request generates a "aws/request.Request" representing the 4200// client's request for the InputService20TestCaseOperation2 operation. The "output" return 4201// value will be populated with the request's response once the request completes 4202// successfully. 4203// 4204// Use "Send" method on the returned Request to send the API call to the service. 4205// the "output" return value is not valid until after Send returns without error. 4206// 4207// See InputService20TestCaseOperation2 for more information on using the InputService20TestCaseOperation2 4208// API call, and error handling. 4209// 4210// This method is useful when you want to inject custom logic or configuration 4211// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4212// 4213// 4214// // Example sending a request using the InputService20TestCaseOperation2Request method. 4215// req, resp := client.InputService20TestCaseOperation2Request(params) 4216// 4217// err := req.Send() 4218// if err == nil { // resp is now filled 4219// fmt.Println(resp) 4220// } 4221func (c *InputService20ProtocolTest) InputService20TestCaseOperation2Request(input *InputService20TestShapeInputService20TestCaseOperation2Input) (req *request.Request, output *InputService20TestShapeInputService20TestCaseOperation2Output) { 4222 op := &request.Operation{ 4223 Name: opInputService20TestCaseOperation2, 4224 HTTPMethod: "POST", 4225 HTTPPath: "/path", 4226 } 4227 4228 if input == nil { 4229 input = &InputService20TestShapeInputService20TestCaseOperation2Input{} 4230 } 4231 4232 output = &InputService20TestShapeInputService20TestCaseOperation2Output{} 4233 req = c.newRequest(op, input, output) 4234 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4235 return 4236} 4237 4238// InputService20TestCaseOperation2 API operation for . 4239// 4240// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4241// with awserr.Error's Code and Message methods to get detailed information about 4242// the error. 4243// 4244// See the AWS API reference guide for 's 4245// API operation InputService20TestCaseOperation2 for usage and error information. 4246func (c *InputService20ProtocolTest) InputService20TestCaseOperation2(input *InputService20TestShapeInputService20TestCaseOperation2Input) (*InputService20TestShapeInputService20TestCaseOperation2Output, error) { 4247 req, out := c.InputService20TestCaseOperation2Request(input) 4248 return out, req.Send() 4249} 4250 4251// InputService20TestCaseOperation2WithContext is the same as InputService20TestCaseOperation2 with the addition of 4252// the ability to pass a context and additional request options. 4253// 4254// See InputService20TestCaseOperation2 for details on how to use this API operation. 4255// 4256// The context must be non-nil and will be used for request cancellation. If 4257// the context is nil a panic will occur. In the future the SDK may create 4258// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4259// for more information on using Contexts. 4260func (c *InputService20ProtocolTest) InputService20TestCaseOperation2WithContext(ctx aws.Context, input *InputService20TestShapeInputService20TestCaseOperation2Input, opts ...request.Option) (*InputService20TestShapeInputService20TestCaseOperation2Output, error) { 4261 req, out := c.InputService20TestCaseOperation2Request(input) 4262 req.SetContext(ctx) 4263 req.ApplyOptions(opts...) 4264 return out, req.Send() 4265} 4266 4267type InputService20TestShapeInputService20TestCaseOperation1Input struct { 4268 _ struct{} `type:"structure"` 4269 4270 Token *string `type:"string" idempotencyToken:"true"` 4271} 4272 4273// SetToken sets the Token field's value. 4274func (s *InputService20TestShapeInputService20TestCaseOperation1Input) SetToken(v string) *InputService20TestShapeInputService20TestCaseOperation1Input { 4275 s.Token = &v 4276 return s 4277} 4278 4279type InputService20TestShapeInputService20TestCaseOperation1Output struct { 4280 _ struct{} `type:"structure"` 4281} 4282 4283type InputService20TestShapeInputService20TestCaseOperation2Input struct { 4284 _ struct{} `type:"structure"` 4285 4286 Token *string `type:"string" idempotencyToken:"true"` 4287} 4288 4289// SetToken sets the Token field's value. 4290func (s *InputService20TestShapeInputService20TestCaseOperation2Input) SetToken(v string) *InputService20TestShapeInputService20TestCaseOperation2Input { 4291 s.Token = &v 4292 return s 4293} 4294 4295type InputService20TestShapeInputService20TestCaseOperation2Output struct { 4296 _ struct{} `type:"structure"` 4297} 4298 4299// InputService21ProtocolTest provides the API operation methods for making requests to 4300// . See this package's package overview docs 4301// for details on the service. 4302// 4303// InputService21ProtocolTest methods are safe to use concurrently. It is not safe to 4304// modify mutate any of the struct's properties though. 4305type InputService21ProtocolTest struct { 4306 *client.Client 4307} 4308 4309// New creates a new instance of the InputService21ProtocolTest client with a session. 4310// If additional configuration is needed for the client instance use the optional 4311// aws.Config parameter to add your extra config. 4312// 4313// Example: 4314// mySession := session.Must(session.NewSession()) 4315// 4316// // Create a InputService21ProtocolTest client from just a session. 4317// svc := inputservice21protocoltest.New(mySession) 4318// 4319// // Create a InputService21ProtocolTest client with additional configuration 4320// svc := inputservice21protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4321func NewInputService21ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService21ProtocolTest { 4322 c := p.ClientConfig("inputservice21protocoltest", cfgs...) 4323 return newInputService21ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 4324} 4325 4326// newClient creates, initializes and returns a new service client instance. 4327func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService21ProtocolTest { 4328 svc := &InputService21ProtocolTest{ 4329 Client: client.New( 4330 cfg, 4331 metadata.ClientInfo{ 4332 ServiceName: "InputService21ProtocolTest", 4333 ServiceID: "InputService21ProtocolTest", 4334 SigningName: signingName, 4335 SigningRegion: signingRegion, 4336 PartitionID: partitionID, 4337 Endpoint: endpoint, 4338 APIVersion: "2014-01-01", 4339 }, 4340 handlers, 4341 ), 4342 } 4343 4344 // Handlers 4345 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4346 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 4347 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 4348 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 4349 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 4350 4351 return svc 4352} 4353 4354// newRequest creates a new request for a InputService21ProtocolTest operation and runs any 4355// custom request initialization. 4356func (c *InputService21ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4357 req := c.NewRequest(op, params, data) 4358 4359 return req 4360} 4361 4362const opInputService21TestCaseOperation1 = "OperationName" 4363 4364// InputService21TestCaseOperation1Request generates a "aws/request.Request" representing the 4365// client's request for the InputService21TestCaseOperation1 operation. The "output" return 4366// value will be populated with the request's response once the request completes 4367// successfully. 4368// 4369// Use "Send" method on the returned Request to send the API call to the service. 4370// the "output" return value is not valid until after Send returns without error. 4371// 4372// See InputService21TestCaseOperation1 for more information on using the InputService21TestCaseOperation1 4373// API call, and error handling. 4374// 4375// This method is useful when you want to inject custom logic or configuration 4376// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4377// 4378// 4379// // Example sending a request using the InputService21TestCaseOperation1Request method. 4380// req, resp := client.InputService21TestCaseOperation1Request(params) 4381// 4382// err := req.Send() 4383// if err == nil { // resp is now filled 4384// fmt.Println(resp) 4385// } 4386func (c *InputService21ProtocolTest) InputService21TestCaseOperation1Request(input *InputService21TestShapeInputService21TestCaseOperation1Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation1Output) { 4387 op := &request.Operation{ 4388 Name: opInputService21TestCaseOperation1, 4389 HTTPMethod: "POST", 4390 HTTPPath: "/", 4391 } 4392 4393 if input == nil { 4394 input = &InputService21TestShapeInputService21TestCaseOperation1Input{} 4395 } 4396 4397 output = &InputService21TestShapeInputService21TestCaseOperation1Output{} 4398 req = c.newRequest(op, input, output) 4399 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4400 return 4401} 4402 4403// InputService21TestCaseOperation1 API operation for . 4404// 4405// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4406// with awserr.Error's Code and Message methods to get detailed information about 4407// the error. 4408// 4409// See the AWS API reference guide for 's 4410// API operation InputService21TestCaseOperation1 for usage and error information. 4411func (c *InputService21ProtocolTest) InputService21TestCaseOperation1(input *InputService21TestShapeInputService21TestCaseOperation1Input) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 4412 req, out := c.InputService21TestCaseOperation1Request(input) 4413 return out, req.Send() 4414} 4415 4416// InputService21TestCaseOperation1WithContext is the same as InputService21TestCaseOperation1 with the addition of 4417// the ability to pass a context and additional request options. 4418// 4419// See InputService21TestCaseOperation1 for details on how to use this API operation. 4420// 4421// The context must be non-nil and will be used for request cancellation. If 4422// the context is nil a panic will occur. In the future the SDK may create 4423// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4424// for more information on using Contexts. 4425func (c *InputService21ProtocolTest) InputService21TestCaseOperation1WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation1Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 4426 req, out := c.InputService21TestCaseOperation1Request(input) 4427 req.SetContext(ctx) 4428 req.ApplyOptions(opts...) 4429 return out, req.Send() 4430} 4431 4432const opInputService21TestCaseOperation2 = "OperationName" 4433 4434// InputService21TestCaseOperation2Request generates a "aws/request.Request" representing the 4435// client's request for the InputService21TestCaseOperation2 operation. The "output" return 4436// value will be populated with the request's response once the request completes 4437// successfully. 4438// 4439// Use "Send" method on the returned Request to send the API call to the service. 4440// the "output" return value is not valid until after Send returns without error. 4441// 4442// See InputService21TestCaseOperation2 for more information on using the InputService21TestCaseOperation2 4443// API call, and error handling. 4444// 4445// This method is useful when you want to inject custom logic or configuration 4446// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4447// 4448// 4449// // Example sending a request using the InputService21TestCaseOperation2Request method. 4450// req, resp := client.InputService21TestCaseOperation2Request(params) 4451// 4452// err := req.Send() 4453// if err == nil { // resp is now filled 4454// fmt.Println(resp) 4455// } 4456func (c *InputService21ProtocolTest) InputService21TestCaseOperation2Request(input *InputService21TestShapeInputService21TestCaseOperation2Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation2Output) { 4457 op := &request.Operation{ 4458 Name: opInputService21TestCaseOperation2, 4459 HTTPMethod: "POST", 4460 HTTPPath: "/", 4461 } 4462 4463 if input == nil { 4464 input = &InputService21TestShapeInputService21TestCaseOperation2Input{} 4465 } 4466 4467 output = &InputService21TestShapeInputService21TestCaseOperation2Output{} 4468 req = c.newRequest(op, input, output) 4469 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4470 return 4471} 4472 4473// InputService21TestCaseOperation2 API operation for . 4474// 4475// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4476// with awserr.Error's Code and Message methods to get detailed information about 4477// the error. 4478// 4479// See the AWS API reference guide for 's 4480// API operation InputService21TestCaseOperation2 for usage and error information. 4481func (c *InputService21ProtocolTest) InputService21TestCaseOperation2(input *InputService21TestShapeInputService21TestCaseOperation2Input) (*InputService21TestShapeInputService21TestCaseOperation2Output, error) { 4482 req, out := c.InputService21TestCaseOperation2Request(input) 4483 return out, req.Send() 4484} 4485 4486// InputService21TestCaseOperation2WithContext is the same as InputService21TestCaseOperation2 with the addition of 4487// the ability to pass a context and additional request options. 4488// 4489// See InputService21TestCaseOperation2 for details on how to use this API operation. 4490// 4491// The context must be non-nil and will be used for request cancellation. If 4492// the context is nil a panic will occur. In the future the SDK may create 4493// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4494// for more information on using Contexts. 4495func (c *InputService21ProtocolTest) InputService21TestCaseOperation2WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation2Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation2Output, error) { 4496 req, out := c.InputService21TestCaseOperation2Request(input) 4497 req.SetContext(ctx) 4498 req.ApplyOptions(opts...) 4499 return out, req.Send() 4500} 4501 4502const opInputService21TestCaseOperation3 = "OperationName" 4503 4504// InputService21TestCaseOperation3Request generates a "aws/request.Request" representing the 4505// client's request for the InputService21TestCaseOperation3 operation. The "output" return 4506// value will be populated with the request's response once the request completes 4507// successfully. 4508// 4509// Use "Send" method on the returned Request to send the API call to the service. 4510// the "output" return value is not valid until after Send returns without error. 4511// 4512// See InputService21TestCaseOperation3 for more information on using the InputService21TestCaseOperation3 4513// API call, and error handling. 4514// 4515// This method is useful when you want to inject custom logic or configuration 4516// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4517// 4518// 4519// // Example sending a request using the InputService21TestCaseOperation3Request method. 4520// req, resp := client.InputService21TestCaseOperation3Request(params) 4521// 4522// err := req.Send() 4523// if err == nil { // resp is now filled 4524// fmt.Println(resp) 4525// } 4526func (c *InputService21ProtocolTest) InputService21TestCaseOperation3Request(input *InputService21TestShapeInputService21TestCaseOperation3Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation3Output) { 4527 op := &request.Operation{ 4528 Name: opInputService21TestCaseOperation3, 4529 HTTPMethod: "POST", 4530 HTTPPath: "/", 4531 } 4532 4533 if input == nil { 4534 input = &InputService21TestShapeInputService21TestCaseOperation3Input{} 4535 } 4536 4537 output = &InputService21TestShapeInputService21TestCaseOperation3Output{} 4538 req = c.newRequest(op, input, output) 4539 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4540 return 4541} 4542 4543// InputService21TestCaseOperation3 API operation for . 4544// 4545// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4546// with awserr.Error's Code and Message methods to get detailed information about 4547// the error. 4548// 4549// See the AWS API reference guide for 's 4550// API operation InputService21TestCaseOperation3 for usage and error information. 4551func (c *InputService21ProtocolTest) InputService21TestCaseOperation3(input *InputService21TestShapeInputService21TestCaseOperation3Input) (*InputService21TestShapeInputService21TestCaseOperation3Output, error) { 4552 req, out := c.InputService21TestCaseOperation3Request(input) 4553 return out, req.Send() 4554} 4555 4556// InputService21TestCaseOperation3WithContext is the same as InputService21TestCaseOperation3 with the addition of 4557// the ability to pass a context and additional request options. 4558// 4559// See InputService21TestCaseOperation3 for details on how to use this API operation. 4560// 4561// The context must be non-nil and will be used for request cancellation. If 4562// the context is nil a panic will occur. In the future the SDK may create 4563// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4564// for more information on using Contexts. 4565func (c *InputService21ProtocolTest) InputService21TestCaseOperation3WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation3Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation3Output, error) { 4566 req, out := c.InputService21TestCaseOperation3Request(input) 4567 req.SetContext(ctx) 4568 req.ApplyOptions(opts...) 4569 return out, req.Send() 4570} 4571 4572type InputService21TestShapeBodyStructure struct { 4573 _ struct{} `type:"structure"` 4574 4575 BodyField aws.JSONValue `type:"jsonvalue"` 4576 4577 BodyListField []aws.JSONValue `type:"list"` 4578} 4579 4580// SetBodyField sets the BodyField field's value. 4581func (s *InputService21TestShapeBodyStructure) SetBodyField(v aws.JSONValue) *InputService21TestShapeBodyStructure { 4582 s.BodyField = v 4583 return s 4584} 4585 4586// SetBodyListField sets the BodyListField field's value. 4587func (s *InputService21TestShapeBodyStructure) SetBodyListField(v []aws.JSONValue) *InputService21TestShapeBodyStructure { 4588 s.BodyListField = v 4589 return s 4590} 4591 4592type InputService21TestShapeInputService21TestCaseOperation1Input struct { 4593 _ struct{} `type:"structure" payload:"Body"` 4594 4595 Body *InputService21TestShapeBodyStructure `type:"structure"` 4596 4597 HeaderField aws.JSONValue `location:"header" locationName:"X-Amz-Foo" type:"jsonvalue"` 4598 4599 QueryField aws.JSONValue `location:"querystring" locationName:"Bar" type:"jsonvalue"` 4600} 4601 4602// SetBody sets the Body field's value. 4603func (s *InputService21TestShapeInputService21TestCaseOperation1Input) SetBody(v *InputService21TestShapeBodyStructure) *InputService21TestShapeInputService21TestCaseOperation1Input { 4604 s.Body = v 4605 return s 4606} 4607 4608// SetHeaderField sets the HeaderField field's value. 4609func (s *InputService21TestShapeInputService21TestCaseOperation1Input) SetHeaderField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation1Input { 4610 s.HeaderField = v 4611 return s 4612} 4613 4614// SetQueryField sets the QueryField field's value. 4615func (s *InputService21TestShapeInputService21TestCaseOperation1Input) SetQueryField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation1Input { 4616 s.QueryField = v 4617 return s 4618} 4619 4620type InputService21TestShapeInputService21TestCaseOperation1Output struct { 4621 _ struct{} `type:"structure"` 4622} 4623 4624type InputService21TestShapeInputService21TestCaseOperation2Input struct { 4625 _ struct{} `type:"structure" payload:"Body"` 4626 4627 Body *InputService21TestShapeBodyStructure `type:"structure"` 4628 4629 HeaderField aws.JSONValue `location:"header" locationName:"X-Amz-Foo" type:"jsonvalue"` 4630 4631 QueryField aws.JSONValue `location:"querystring" locationName:"Bar" type:"jsonvalue"` 4632} 4633 4634// SetBody sets the Body field's value. 4635func (s *InputService21TestShapeInputService21TestCaseOperation2Input) SetBody(v *InputService21TestShapeBodyStructure) *InputService21TestShapeInputService21TestCaseOperation2Input { 4636 s.Body = v 4637 return s 4638} 4639 4640// SetHeaderField sets the HeaderField field's value. 4641func (s *InputService21TestShapeInputService21TestCaseOperation2Input) SetHeaderField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation2Input { 4642 s.HeaderField = v 4643 return s 4644} 4645 4646// SetQueryField sets the QueryField field's value. 4647func (s *InputService21TestShapeInputService21TestCaseOperation2Input) SetQueryField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation2Input { 4648 s.QueryField = v 4649 return s 4650} 4651 4652type InputService21TestShapeInputService21TestCaseOperation2Output struct { 4653 _ struct{} `type:"structure"` 4654} 4655 4656type InputService21TestShapeInputService21TestCaseOperation3Input struct { 4657 _ struct{} `type:"structure" payload:"Body"` 4658 4659 Body *InputService21TestShapeBodyStructure `type:"structure"` 4660 4661 HeaderField aws.JSONValue `location:"header" locationName:"X-Amz-Foo" type:"jsonvalue"` 4662 4663 QueryField aws.JSONValue `location:"querystring" locationName:"Bar" type:"jsonvalue"` 4664} 4665 4666// SetBody sets the Body field's value. 4667func (s *InputService21TestShapeInputService21TestCaseOperation3Input) SetBody(v *InputService21TestShapeBodyStructure) *InputService21TestShapeInputService21TestCaseOperation3Input { 4668 s.Body = v 4669 return s 4670} 4671 4672// SetHeaderField sets the HeaderField field's value. 4673func (s *InputService21TestShapeInputService21TestCaseOperation3Input) SetHeaderField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation3Input { 4674 s.HeaderField = v 4675 return s 4676} 4677 4678// SetQueryField sets the QueryField field's value. 4679func (s *InputService21TestShapeInputService21TestCaseOperation3Input) SetQueryField(v aws.JSONValue) *InputService21TestShapeInputService21TestCaseOperation3Input { 4680 s.QueryField = v 4681 return s 4682} 4683 4684type InputService21TestShapeInputService21TestCaseOperation3Output struct { 4685 _ struct{} `type:"structure"` 4686} 4687 4688// InputService22ProtocolTest provides the API operation methods for making requests to 4689// . See this package's package overview docs 4690// for details on the service. 4691// 4692// InputService22ProtocolTest methods are safe to use concurrently. It is not safe to 4693// modify mutate any of the struct's properties though. 4694type InputService22ProtocolTest struct { 4695 *client.Client 4696} 4697 4698// New creates a new instance of the InputService22ProtocolTest client with a session. 4699// If additional configuration is needed for the client instance use the optional 4700// aws.Config parameter to add your extra config. 4701// 4702// Example: 4703// mySession := session.Must(session.NewSession()) 4704// 4705// // Create a InputService22ProtocolTest client from just a session. 4706// svc := inputservice22protocoltest.New(mySession) 4707// 4708// // Create a InputService22ProtocolTest client with additional configuration 4709// svc := inputservice22protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4710func NewInputService22ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService22ProtocolTest { 4711 c := p.ClientConfig("inputservice22protocoltest", cfgs...) 4712 return newInputService22ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 4713} 4714 4715// newClient creates, initializes and returns a new service client instance. 4716func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService22ProtocolTest { 4717 svc := &InputService22ProtocolTest{ 4718 Client: client.New( 4719 cfg, 4720 metadata.ClientInfo{ 4721 ServiceName: "InputService22ProtocolTest", 4722 ServiceID: "InputService22ProtocolTest", 4723 SigningName: signingName, 4724 SigningRegion: signingRegion, 4725 PartitionID: partitionID, 4726 Endpoint: endpoint, 4727 APIVersion: "2014-01-01", 4728 }, 4729 handlers, 4730 ), 4731 } 4732 4733 // Handlers 4734 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4735 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 4736 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 4737 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 4738 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 4739 4740 return svc 4741} 4742 4743// newRequest creates a new request for a InputService22ProtocolTest operation and runs any 4744// custom request initialization. 4745func (c *InputService22ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4746 req := c.NewRequest(op, params, data) 4747 4748 return req 4749} 4750 4751const opInputService22TestCaseOperation1 = "OperationName" 4752 4753// InputService22TestCaseOperation1Request generates a "aws/request.Request" representing the 4754// client's request for the InputService22TestCaseOperation1 operation. The "output" return 4755// value will be populated with the request's response once the request completes 4756// successfully. 4757// 4758// Use "Send" method on the returned Request to send the API call to the service. 4759// the "output" return value is not valid until after Send returns without error. 4760// 4761// See InputService22TestCaseOperation1 for more information on using the InputService22TestCaseOperation1 4762// API call, and error handling. 4763// 4764// This method is useful when you want to inject custom logic or configuration 4765// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4766// 4767// 4768// // Example sending a request using the InputService22TestCaseOperation1Request method. 4769// req, resp := client.InputService22TestCaseOperation1Request(params) 4770// 4771// err := req.Send() 4772// if err == nil { // resp is now filled 4773// fmt.Println(resp) 4774// } 4775func (c *InputService22ProtocolTest) InputService22TestCaseOperation1Request(input *InputService22TestShapeInputService22TestCaseOperation1Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation1Output) { 4776 op := &request.Operation{ 4777 Name: opInputService22TestCaseOperation1, 4778 HTTPMethod: "POST", 4779 HTTPPath: "/path", 4780 } 4781 4782 if input == nil { 4783 input = &InputService22TestShapeInputService22TestCaseOperation1Input{} 4784 } 4785 4786 output = &InputService22TestShapeInputService22TestCaseOperation1Output{} 4787 req = c.newRequest(op, input, output) 4788 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4789 return 4790} 4791 4792// InputService22TestCaseOperation1 API operation for . 4793// 4794// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4795// with awserr.Error's Code and Message methods to get detailed information about 4796// the error. 4797// 4798// See the AWS API reference guide for 's 4799// API operation InputService22TestCaseOperation1 for usage and error information. 4800func (c *InputService22ProtocolTest) InputService22TestCaseOperation1(input *InputService22TestShapeInputService22TestCaseOperation1Input) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4801 req, out := c.InputService22TestCaseOperation1Request(input) 4802 return out, req.Send() 4803} 4804 4805// InputService22TestCaseOperation1WithContext is the same as InputService22TestCaseOperation1 with the addition of 4806// the ability to pass a context and additional request options. 4807// 4808// See InputService22TestCaseOperation1 for details on how to use this API operation. 4809// 4810// The context must be non-nil and will be used for request cancellation. If 4811// the context is nil a panic will occur. In the future the SDK may create 4812// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4813// for more information on using Contexts. 4814func (c *InputService22ProtocolTest) InputService22TestCaseOperation1WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation1Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4815 req, out := c.InputService22TestCaseOperation1Request(input) 4816 req.SetContext(ctx) 4817 req.ApplyOptions(opts...) 4818 return out, req.Send() 4819} 4820 4821const opInputService22TestCaseOperation2 = "OperationName" 4822 4823// InputService22TestCaseOperation2Request generates a "aws/request.Request" representing the 4824// client's request for the InputService22TestCaseOperation2 operation. The "output" return 4825// value will be populated with the request's response once the request completes 4826// successfully. 4827// 4828// Use "Send" method on the returned Request to send the API call to the service. 4829// the "output" return value is not valid until after Send returns without error. 4830// 4831// See InputService22TestCaseOperation2 for more information on using the InputService22TestCaseOperation2 4832// API call, and error handling. 4833// 4834// This method is useful when you want to inject custom logic or configuration 4835// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4836// 4837// 4838// // Example sending a request using the InputService22TestCaseOperation2Request method. 4839// req, resp := client.InputService22TestCaseOperation2Request(params) 4840// 4841// err := req.Send() 4842// if err == nil { // resp is now filled 4843// fmt.Println(resp) 4844// } 4845func (c *InputService22ProtocolTest) InputService22TestCaseOperation2Request(input *InputService22TestShapeInputService22TestCaseOperation2Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation2Output) { 4846 op := &request.Operation{ 4847 Name: opInputService22TestCaseOperation2, 4848 HTTPMethod: "POST", 4849 HTTPPath: "/path", 4850 } 4851 4852 if input == nil { 4853 input = &InputService22TestShapeInputService22TestCaseOperation2Input{} 4854 } 4855 4856 output = &InputService22TestShapeInputService22TestCaseOperation2Output{} 4857 req = c.newRequest(op, input, output) 4858 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4859 return 4860} 4861 4862// InputService22TestCaseOperation2 API operation for . 4863// 4864// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4865// with awserr.Error's Code and Message methods to get detailed information about 4866// the error. 4867// 4868// See the AWS API reference guide for 's 4869// API operation InputService22TestCaseOperation2 for usage and error information. 4870func (c *InputService22ProtocolTest) InputService22TestCaseOperation2(input *InputService22TestShapeInputService22TestCaseOperation2Input) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4871 req, out := c.InputService22TestCaseOperation2Request(input) 4872 return out, req.Send() 4873} 4874 4875// InputService22TestCaseOperation2WithContext is the same as InputService22TestCaseOperation2 with the addition of 4876// the ability to pass a context and additional request options. 4877// 4878// See InputService22TestCaseOperation2 for details on how to use this API operation. 4879// 4880// The context must be non-nil and will be used for request cancellation. If 4881// the context is nil a panic will occur. In the future the SDK may create 4882// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4883// for more information on using Contexts. 4884func (c *InputService22ProtocolTest) InputService22TestCaseOperation2WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation2Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4885 req, out := c.InputService22TestCaseOperation2Request(input) 4886 req.SetContext(ctx) 4887 req.ApplyOptions(opts...) 4888 return out, req.Send() 4889} 4890 4891type InputService22TestShapeInputService22TestCaseOperation1Input struct { 4892 _ struct{} `type:"structure"` 4893 4894 FooEnum *string `type:"string" enum:"InputService22TestShapeEnumType"` 4895 4896 HeaderEnum *string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService22TestShapeEnumType"` 4897 4898 ListEnums []*string `type:"list"` 4899 4900 QueryFooEnum *string `location:"querystring" locationName:"Enum" type:"string" enum:"InputService22TestShapeEnumType"` 4901 4902 QueryListEnums []*string `location:"querystring" locationName:"List" type:"list"` 4903} 4904 4905// SetFooEnum sets the FooEnum field's value. 4906func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetFooEnum(v string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4907 s.FooEnum = &v 4908 return s 4909} 4910 4911// SetHeaderEnum sets the HeaderEnum field's value. 4912func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetHeaderEnum(v string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4913 s.HeaderEnum = &v 4914 return s 4915} 4916 4917// SetListEnums sets the ListEnums field's value. 4918func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetListEnums(v []*string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4919 s.ListEnums = v 4920 return s 4921} 4922 4923// SetQueryFooEnum sets the QueryFooEnum field's value. 4924func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetQueryFooEnum(v string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4925 s.QueryFooEnum = &v 4926 return s 4927} 4928 4929// SetQueryListEnums sets the QueryListEnums field's value. 4930func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetQueryListEnums(v []*string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4931 s.QueryListEnums = v 4932 return s 4933} 4934 4935type InputService22TestShapeInputService22TestCaseOperation1Output struct { 4936 _ struct{} `type:"structure"` 4937} 4938 4939type InputService22TestShapeInputService22TestCaseOperation2Input struct { 4940 _ struct{} `type:"structure"` 4941 4942 FooEnum *string `type:"string" enum:"InputService22TestShapeEnumType"` 4943 4944 HeaderEnum *string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService22TestShapeEnumType"` 4945 4946 ListEnums []*string `type:"list"` 4947 4948 QueryFooEnum *string `location:"querystring" locationName:"Enum" type:"string" enum:"InputService22TestShapeEnumType"` 4949 4950 QueryListEnums []*string `location:"querystring" locationName:"List" type:"list"` 4951} 4952 4953// SetFooEnum sets the FooEnum field's value. 4954func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetFooEnum(v string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4955 s.FooEnum = &v 4956 return s 4957} 4958 4959// SetHeaderEnum sets the HeaderEnum field's value. 4960func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetHeaderEnum(v string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4961 s.HeaderEnum = &v 4962 return s 4963} 4964 4965// SetListEnums sets the ListEnums field's value. 4966func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetListEnums(v []*string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4967 s.ListEnums = v 4968 return s 4969} 4970 4971// SetQueryFooEnum sets the QueryFooEnum field's value. 4972func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetQueryFooEnum(v string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4973 s.QueryFooEnum = &v 4974 return s 4975} 4976 4977// SetQueryListEnums sets the QueryListEnums field's value. 4978func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetQueryListEnums(v []*string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4979 s.QueryListEnums = v 4980 return s 4981} 4982 4983type InputService22TestShapeInputService22TestCaseOperation2Output struct { 4984 _ struct{} `type:"structure"` 4985} 4986 4987const ( 4988 // EnumTypeFoo is a InputService22TestShapeEnumType enum value 4989 EnumTypeFoo = "foo" 4990 4991 // EnumTypeBar is a InputService22TestShapeEnumType enum value 4992 EnumTypeBar = "bar" 4993 4994 // EnumType0 is a InputService22TestShapeEnumType enum value 4995 EnumType0 = "0" 4996 4997 // EnumType1 is a InputService22TestShapeEnumType enum value 4998 EnumType1 = "1" 4999) 5000 5001// InputService22TestShapeEnumType_Values returns all elements of the InputService22TestShapeEnumType enum 5002func InputService22TestShapeEnumType_Values() []string { 5003 return []string{ 5004 EnumTypeFoo, 5005 EnumTypeBar, 5006 EnumType0, 5007 EnumType1, 5008 } 5009} 5010 5011// InputService23ProtocolTest provides the API operation methods for making requests to 5012// . See this package's package overview docs 5013// for details on the service. 5014// 5015// InputService23ProtocolTest methods are safe to use concurrently. It is not safe to 5016// modify mutate any of the struct's properties though. 5017type InputService23ProtocolTest struct { 5018 *client.Client 5019} 5020 5021// New creates a new instance of the InputService23ProtocolTest client with a session. 5022// If additional configuration is needed for the client instance use the optional 5023// aws.Config parameter to add your extra config. 5024// 5025// Example: 5026// mySession := session.Must(session.NewSession()) 5027// 5028// // Create a InputService23ProtocolTest client from just a session. 5029// svc := inputservice23protocoltest.New(mySession) 5030// 5031// // Create a InputService23ProtocolTest client with additional configuration 5032// svc := inputservice23protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 5033func NewInputService23ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService23ProtocolTest { 5034 c := p.ClientConfig("inputservice23protocoltest", cfgs...) 5035 return newInputService23ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 5036} 5037 5038// newClient creates, initializes and returns a new service client instance. 5039func newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService23ProtocolTest { 5040 svc := &InputService23ProtocolTest{ 5041 Client: client.New( 5042 cfg, 5043 metadata.ClientInfo{ 5044 ServiceName: "InputService23ProtocolTest", 5045 ServiceID: "InputService23ProtocolTest", 5046 SigningName: signingName, 5047 SigningRegion: signingRegion, 5048 PartitionID: partitionID, 5049 Endpoint: endpoint, 5050 APIVersion: "2014-01-01", 5051 }, 5052 handlers, 5053 ), 5054 } 5055 5056 // Handlers 5057 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5058 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 5059 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 5060 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 5061 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 5062 5063 return svc 5064} 5065 5066// newRequest creates a new request for a InputService23ProtocolTest operation and runs any 5067// custom request initialization. 5068func (c *InputService23ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5069 req := c.NewRequest(op, params, data) 5070 5071 return req 5072} 5073 5074const opInputService23TestCaseOperation1 = "StaticOp" 5075 5076// InputService23TestCaseOperation1Request generates a "aws/request.Request" representing the 5077// client's request for the InputService23TestCaseOperation1 operation. The "output" return 5078// value will be populated with the request's response once the request completes 5079// successfully. 5080// 5081// Use "Send" method on the returned Request to send the API call to the service. 5082// the "output" return value is not valid until after Send returns without error. 5083// 5084// See InputService23TestCaseOperation1 for more information on using the InputService23TestCaseOperation1 5085// API call, and error handling. 5086// 5087// This method is useful when you want to inject custom logic or configuration 5088// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5089// 5090// 5091// // Example sending a request using the InputService23TestCaseOperation1Request method. 5092// req, resp := client.InputService23TestCaseOperation1Request(params) 5093// 5094// err := req.Send() 5095// if err == nil { // resp is now filled 5096// fmt.Println(resp) 5097// } 5098func (c *InputService23ProtocolTest) InputService23TestCaseOperation1Request(input *InputService23TestShapeInputService23TestCaseOperation1Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation1Output) { 5099 op := &request.Operation{ 5100 Name: opInputService23TestCaseOperation1, 5101 HTTPMethod: "POST", 5102 HTTPPath: "/path", 5103 } 5104 5105 if input == nil { 5106 input = &InputService23TestShapeInputService23TestCaseOperation1Input{} 5107 } 5108 5109 output = &InputService23TestShapeInputService23TestCaseOperation1Output{} 5110 req = c.newRequest(op, input, output) 5111 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5112 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("data-", nil)) 5113 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 5114 return 5115} 5116 5117// InputService23TestCaseOperation1 API operation for . 5118// 5119// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5120// with awserr.Error's Code and Message methods to get detailed information about 5121// the error. 5122// 5123// See the AWS API reference guide for 's 5124// API operation InputService23TestCaseOperation1 for usage and error information. 5125func (c *InputService23ProtocolTest) InputService23TestCaseOperation1(input *InputService23TestShapeInputService23TestCaseOperation1Input) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 5126 req, out := c.InputService23TestCaseOperation1Request(input) 5127 return out, req.Send() 5128} 5129 5130// InputService23TestCaseOperation1WithContext is the same as InputService23TestCaseOperation1 with the addition of 5131// the ability to pass a context and additional request options. 5132// 5133// See InputService23TestCaseOperation1 for details on how to use this API operation. 5134// 5135// The context must be non-nil and will be used for request cancellation. If 5136// the context is nil a panic will occur. In the future the SDK may create 5137// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5138// for more information on using Contexts. 5139func (c *InputService23ProtocolTest) InputService23TestCaseOperation1WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation1Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 5140 req, out := c.InputService23TestCaseOperation1Request(input) 5141 req.SetContext(ctx) 5142 req.ApplyOptions(opts...) 5143 return out, req.Send() 5144} 5145 5146const opInputService23TestCaseOperation2 = "MemberRefOp" 5147 5148// InputService23TestCaseOperation2Request generates a "aws/request.Request" representing the 5149// client's request for the InputService23TestCaseOperation2 operation. The "output" return 5150// value will be populated with the request's response once the request completes 5151// successfully. 5152// 5153// Use "Send" method on the returned Request to send the API call to the service. 5154// the "output" return value is not valid until after Send returns without error. 5155// 5156// See InputService23TestCaseOperation2 for more information on using the InputService23TestCaseOperation2 5157// API call, and error handling. 5158// 5159// This method is useful when you want to inject custom logic or configuration 5160// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5161// 5162// 5163// // Example sending a request using the InputService23TestCaseOperation2Request method. 5164// req, resp := client.InputService23TestCaseOperation2Request(params) 5165// 5166// err := req.Send() 5167// if err == nil { // resp is now filled 5168// fmt.Println(resp) 5169// } 5170func (c *InputService23ProtocolTest) InputService23TestCaseOperation2Request(input *InputService23TestShapeInputService23TestCaseOperation2Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation2Output) { 5171 op := &request.Operation{ 5172 Name: opInputService23TestCaseOperation2, 5173 HTTPMethod: "POST", 5174 HTTPPath: "/path", 5175 } 5176 5177 if input == nil { 5178 input = &InputService23TestShapeInputService23TestCaseOperation2Input{} 5179 } 5180 5181 output = &InputService23TestShapeInputService23TestCaseOperation2Output{} 5182 req = c.newRequest(op, input, output) 5183 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5184 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("foo-{Name}.", input.hostLabels)) 5185 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 5186 return 5187} 5188 5189// InputService23TestCaseOperation2 API operation for . 5190// 5191// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5192// with awserr.Error's Code and Message methods to get detailed information about 5193// the error. 5194// 5195// See the AWS API reference guide for 's 5196// API operation InputService23TestCaseOperation2 for usage and error information. 5197func (c *InputService23ProtocolTest) InputService23TestCaseOperation2(input *InputService23TestShapeInputService23TestCaseOperation2Input) (*InputService23TestShapeInputService23TestCaseOperation2Output, error) { 5198 req, out := c.InputService23TestCaseOperation2Request(input) 5199 return out, req.Send() 5200} 5201 5202// InputService23TestCaseOperation2WithContext is the same as InputService23TestCaseOperation2 with the addition of 5203// the ability to pass a context and additional request options. 5204// 5205// See InputService23TestCaseOperation2 for details on how to use this API operation. 5206// 5207// The context must be non-nil and will be used for request cancellation. If 5208// the context is nil a panic will occur. In the future the SDK may create 5209// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5210// for more information on using Contexts. 5211func (c *InputService23ProtocolTest) InputService23TestCaseOperation2WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation2Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation2Output, error) { 5212 req, out := c.InputService23TestCaseOperation2Request(input) 5213 req.SetContext(ctx) 5214 req.ApplyOptions(opts...) 5215 return out, req.Send() 5216} 5217 5218type InputService23TestShapeInputService23TestCaseOperation1Input struct { 5219 _ struct{} `type:"structure"` 5220 5221 Name *string `type:"string"` 5222} 5223 5224// SetName sets the Name field's value. 5225func (s *InputService23TestShapeInputService23TestCaseOperation1Input) SetName(v string) *InputService23TestShapeInputService23TestCaseOperation1Input { 5226 s.Name = &v 5227 return s 5228} 5229 5230type InputService23TestShapeInputService23TestCaseOperation1Output struct { 5231 _ struct{} `type:"structure"` 5232} 5233 5234type InputService23TestShapeInputService23TestCaseOperation2Input struct { 5235 _ struct{} `type:"structure"` 5236 5237 // Name is a required field 5238 Name *string `type:"string" required:"true"` 5239} 5240 5241// Validate inspects the fields of the type to determine if they are valid. 5242func (s *InputService23TestShapeInputService23TestCaseOperation2Input) Validate() error { 5243 invalidParams := request.ErrInvalidParams{Context: "InputService23TestShapeInputService23TestCaseOperation2Input"} 5244 if s.Name == nil { 5245 invalidParams.Add(request.NewErrParamRequired("Name")) 5246 } 5247 if s.Name != nil && len(*s.Name) < 1 { 5248 invalidParams.Add(request.NewErrParamMinLen("Name", 1)) 5249 } 5250 5251 if invalidParams.Len() > 0 { 5252 return invalidParams 5253 } 5254 return nil 5255} 5256 5257// SetName sets the Name field's value. 5258func (s *InputService23TestShapeInputService23TestCaseOperation2Input) SetName(v string) *InputService23TestShapeInputService23TestCaseOperation2Input { 5259 s.Name = &v 5260 return s 5261} 5262 5263func (s *InputService23TestShapeInputService23TestCaseOperation2Input) hostLabels() map[string]string { 5264 return map[string]string{ 5265 "Name": aws.StringValue(s.Name), 5266 } 5267} 5268 5269type InputService23TestShapeInputService23TestCaseOperation2Output struct { 5270 _ struct{} `type:"structure"` 5271} 5272 5273// InputService24ProtocolTest provides the API operation methods for making requests to 5274// . See this package's package overview docs 5275// for details on the service. 5276// 5277// InputService24ProtocolTest methods are safe to use concurrently. It is not safe to 5278// modify mutate any of the struct's properties though. 5279type InputService24ProtocolTest struct { 5280 *client.Client 5281} 5282 5283// New creates a new instance of the InputService24ProtocolTest client with a session. 5284// If additional configuration is needed for the client instance use the optional 5285// aws.Config parameter to add your extra config. 5286// 5287// Example: 5288// mySession := session.Must(session.NewSession()) 5289// 5290// // Create a InputService24ProtocolTest client from just a session. 5291// svc := inputservice24protocoltest.New(mySession) 5292// 5293// // Create a InputService24ProtocolTest client with additional configuration 5294// svc := inputservice24protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 5295func NewInputService24ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService24ProtocolTest { 5296 c := p.ClientConfig("inputservice24protocoltest", cfgs...) 5297 return newInputService24ProtocolTestClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) 5298} 5299 5300// newClient creates, initializes and returns a new service client instance. 5301func newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *InputService24ProtocolTest { 5302 svc := &InputService24ProtocolTest{ 5303 Client: client.New( 5304 cfg, 5305 metadata.ClientInfo{ 5306 ServiceName: "InputService24ProtocolTest", 5307 ServiceID: "InputService24ProtocolTest", 5308 SigningName: signingName, 5309 SigningRegion: signingRegion, 5310 PartitionID: partitionID, 5311 Endpoint: endpoint, 5312 APIVersion: "2014-01-01", 5313 }, 5314 handlers, 5315 ), 5316 } 5317 5318 // Handlers 5319 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5320 svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) 5321 svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) 5322 svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) 5323 svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) 5324 5325 return svc 5326} 5327 5328// newRequest creates a new request for a InputService24ProtocolTest operation and runs any 5329// custom request initialization. 5330func (c *InputService24ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5331 req := c.NewRequest(op, params, data) 5332 5333 return req 5334} 5335 5336const opInputService24TestCaseOperation1 = "OperationName" 5337 5338// InputService24TestCaseOperation1Request generates a "aws/request.Request" representing the 5339// client's request for the InputService24TestCaseOperation1 operation. The "output" return 5340// value will be populated with the request's response once the request completes 5341// successfully. 5342// 5343// Use "Send" method on the returned Request to send the API call to the service. 5344// the "output" return value is not valid until after Send returns without error. 5345// 5346// See InputService24TestCaseOperation1 for more information on using the InputService24TestCaseOperation1 5347// API call, and error handling. 5348// 5349// This method is useful when you want to inject custom logic or configuration 5350// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5351// 5352// 5353// // Example sending a request using the InputService24TestCaseOperation1Request method. 5354// req, resp := client.InputService24TestCaseOperation1Request(params) 5355// 5356// err := req.Send() 5357// if err == nil { // resp is now filled 5358// fmt.Println(resp) 5359// } 5360func (c *InputService24ProtocolTest) InputService24TestCaseOperation1Request(input *InputService24TestShapeInputService24TestCaseOperation1Input) (req *request.Request, output *InputService24TestShapeInputService24TestCaseOperation1Output) { 5361 op := &request.Operation{ 5362 Name: opInputService24TestCaseOperation1, 5363 HTTPMethod: "GET", 5364 HTTPPath: "/", 5365 } 5366 5367 if input == nil { 5368 input = &InputService24TestShapeInputService24TestCaseOperation1Input{} 5369 } 5370 5371 output = &InputService24TestShapeInputService24TestCaseOperation1Output{} 5372 req = c.newRequest(op, input, output) 5373 req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5374 return 5375} 5376 5377// InputService24TestCaseOperation1 API operation for . 5378// 5379// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5380// with awserr.Error's Code and Message methods to get detailed information about 5381// the error. 5382// 5383// See the AWS API reference guide for 's 5384// API operation InputService24TestCaseOperation1 for usage and error information. 5385func (c *InputService24ProtocolTest) InputService24TestCaseOperation1(input *InputService24TestShapeInputService24TestCaseOperation1Input) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 5386 req, out := c.InputService24TestCaseOperation1Request(input) 5387 return out, req.Send() 5388} 5389 5390// InputService24TestCaseOperation1WithContext is the same as InputService24TestCaseOperation1 with the addition of 5391// the ability to pass a context and additional request options. 5392// 5393// See InputService24TestCaseOperation1 for details on how to use this API operation. 5394// 5395// The context must be non-nil and will be used for request cancellation. If 5396// the context is nil a panic will occur. In the future the SDK may create 5397// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5398// for more information on using Contexts. 5399func (c *InputService24ProtocolTest) InputService24TestCaseOperation1WithContext(ctx aws.Context, input *InputService24TestShapeInputService24TestCaseOperation1Input, opts ...request.Option) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 5400 req, out := c.InputService24TestCaseOperation1Request(input) 5401 req.SetContext(ctx) 5402 req.ApplyOptions(opts...) 5403 return out, req.Send() 5404} 5405 5406type InputService24TestShapeInputService24TestCaseOperation1Input struct { 5407 _ struct{} `type:"structure"` 5408 5409 Header1 *string `location:"header" type:"string"` 5410 5411 HeaderMap map[string]*string `location:"headers" locationName:"header-map-" type:"map"` 5412} 5413 5414// SetHeader1 sets the Header1 field's value. 5415func (s *InputService24TestShapeInputService24TestCaseOperation1Input) SetHeader1(v string) *InputService24TestShapeInputService24TestCaseOperation1Input { 5416 s.Header1 = &v 5417 return s 5418} 5419 5420// SetHeaderMap sets the HeaderMap field's value. 5421func (s *InputService24TestShapeInputService24TestCaseOperation1Input) SetHeaderMap(v map[string]*string) *InputService24TestShapeInputService24TestCaseOperation1Input { 5422 s.HeaderMap = v 5423 return s 5424} 5425 5426type InputService24TestShapeInputService24TestCaseOperation1Output struct { 5427 _ struct{} `type:"structure"` 5428} 5429 5430// 5431// Tests begin here 5432// 5433 5434func TestInputService1ProtocolTestNoParametersCase1(t *testing.T) { 5435 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5436 req, _ := svc.InputService1TestCaseOperation1Request(nil) 5437 r := req.HTTPRequest 5438 5439 // build request 5440 req.Build() 5441 if req.Error != nil { 5442 t.Errorf("expect no error, got %v", req.Error) 5443 } 5444 5445 // assert URL 5446 awstesting.AssertURL(t, "https://test/2014-01-01/jobs", r.URL.String()) 5447 5448 // assert headers 5449 5450} 5451 5452func TestInputService2ProtocolTestURIParameterOnlyWithNoLocationNameCase1(t *testing.T) { 5453 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5454 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 5455 PipelineId: aws.String("foo"), 5456 } 5457 req, _ := svc.InputService2TestCaseOperation1Request(input) 5458 r := req.HTTPRequest 5459 5460 // build request 5461 req.Build() 5462 if req.Error != nil { 5463 t.Errorf("expect no error, got %v", req.Error) 5464 } 5465 5466 // assert URL 5467 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo", r.URL.String()) 5468 5469 // assert headers 5470 5471} 5472 5473func TestInputService3ProtocolTestURIParameterOnlyWithLocationNameCase1(t *testing.T) { 5474 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5475 input := &InputService3TestShapeInputService3TestCaseOperation1Input{ 5476 Foo: aws.String("bar"), 5477 } 5478 req, _ := svc.InputService3TestCaseOperation1Request(input) 5479 r := req.HTTPRequest 5480 5481 // build request 5482 req.Build() 5483 if req.Error != nil { 5484 t.Errorf("expect no error, got %v", req.Error) 5485 } 5486 5487 // assert URL 5488 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/bar", r.URL.String()) 5489 5490 // assert headers 5491 5492} 5493 5494func TestInputService4ProtocolTestQuerystringListOfStringsCase1(t *testing.T) { 5495 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5496 input := &InputService4TestShapeInputService4TestCaseOperation1Input{ 5497 Items: []*string{ 5498 aws.String("value1"), 5499 aws.String("value2"), 5500 }, 5501 } 5502 req, _ := svc.InputService4TestCaseOperation1Request(input) 5503 r := req.HTTPRequest 5504 5505 // build request 5506 req.Build() 5507 if req.Error != nil { 5508 t.Errorf("expect no error, got %v", req.Error) 5509 } 5510 5511 // assert URL 5512 awstesting.AssertURL(t, "https://test/path?item=value1&item=value2", r.URL.String()) 5513 5514 // assert headers 5515 5516} 5517 5518func TestInputService5ProtocolTestStringToStringMapsInQuerystringCase1(t *testing.T) { 5519 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5520 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 5521 PipelineId: aws.String("foo"), 5522 QueryDoc: map[string]*string{ 5523 "bar": aws.String("baz"), 5524 "fizz": aws.String("buzz"), 5525 }, 5526 } 5527 req, _ := svc.InputService5TestCaseOperation1Request(input) 5528 r := req.HTTPRequest 5529 5530 // build request 5531 req.Build() 5532 if req.Error != nil { 5533 t.Errorf("expect no error, got %v", req.Error) 5534 } 5535 5536 // assert URL 5537 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?bar=baz&fizz=buzz", r.URL.String()) 5538 5539 // assert headers 5540 5541} 5542 5543func TestInputService6ProtocolTestStringToStringListMapsInQuerystringCase1(t *testing.T) { 5544 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5545 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 5546 PipelineId: aws.String("id"), 5547 QueryDoc: map[string][]*string{ 5548 "fizz": { 5549 aws.String("buzz"), 5550 aws.String("pop"), 5551 }, 5552 "foo": { 5553 aws.String("bar"), 5554 aws.String("baz"), 5555 }, 5556 }, 5557 } 5558 req, _ := svc.InputService6TestCaseOperation1Request(input) 5559 r := req.HTTPRequest 5560 5561 // build request 5562 req.Build() 5563 if req.Error != nil { 5564 t.Errorf("expect no error, got %v", req.Error) 5565 } 5566 5567 // assert URL 5568 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/id?foo=bar&foo=baz&fizz=buzz&fizz=pop", r.URL.String()) 5569 5570 // assert headers 5571 5572} 5573 5574func TestInputService7ProtocolTestBooleanInQuerystringCase1(t *testing.T) { 5575 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5576 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 5577 BoolQuery: aws.Bool(true), 5578 } 5579 req, _ := svc.InputService7TestCaseOperation1Request(input) 5580 r := req.HTTPRequest 5581 5582 // build request 5583 req.Build() 5584 if req.Error != nil { 5585 t.Errorf("expect no error, got %v", req.Error) 5586 } 5587 5588 // assert URL 5589 awstesting.AssertURL(t, "https://test/path?bool-query=true", r.URL.String()) 5590 5591 // assert headers 5592 5593} 5594 5595func TestInputService7ProtocolTestBooleanInQuerystringCase2(t *testing.T) { 5596 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5597 input := &InputService7TestShapeInputService7TestCaseOperation2Input{ 5598 BoolQuery: aws.Bool(false), 5599 } 5600 req, _ := svc.InputService7TestCaseOperation2Request(input) 5601 r := req.HTTPRequest 5602 5603 // build request 5604 req.Build() 5605 if req.Error != nil { 5606 t.Errorf("expect no error, got %v", req.Error) 5607 } 5608 5609 // assert URL 5610 awstesting.AssertURL(t, "https://test/path?bool-query=false", r.URL.String()) 5611 5612 // assert headers 5613 5614} 5615 5616func TestInputService8ProtocolTestURIParameterAndQuerystringParamsCase1(t *testing.T) { 5617 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5618 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 5619 Ascending: aws.String("true"), 5620 PageToken: aws.String("bar"), 5621 PipelineId: aws.String("foo"), 5622 } 5623 req, _ := svc.InputService8TestCaseOperation1Request(input) 5624 r := req.HTTPRequest 5625 5626 // build request 5627 req.Build() 5628 if req.Error != nil { 5629 t.Errorf("expect no error, got %v", req.Error) 5630 } 5631 5632 // assert URL 5633 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?Ascending=true&PageToken=bar", r.URL.String()) 5634 5635 // assert headers 5636 5637} 5638 5639func TestInputService9ProtocolTestURIParameterQuerystringParamsAndJSONBodyCase1(t *testing.T) { 5640 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5641 input := &InputService9TestShapeInputService9TestCaseOperation1Input{ 5642 Ascending: aws.String("true"), 5643 Config: &InputService9TestShapeStructType{ 5644 A: aws.String("one"), 5645 B: aws.String("two"), 5646 }, 5647 PageToken: aws.String("bar"), 5648 PipelineId: aws.String("foo"), 5649 } 5650 req, _ := svc.InputService9TestCaseOperation1Request(input) 5651 r := req.HTTPRequest 5652 5653 // build request 5654 req.Build() 5655 if req.Error != nil { 5656 t.Errorf("expect no error, got %v", req.Error) 5657 } 5658 5659 // assert body 5660 if r.Body == nil { 5661 t.Errorf("expect body not to be nil") 5662 } 5663 body, _ := ioutil.ReadAll(r.Body) 5664 awstesting.AssertJSON(t, `{"Config": {"A": "one", "B": "two"}}`, util.Trim(string(body))) 5665 5666 // assert URL 5667 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?Ascending=true&PageToken=bar", r.URL.String()) 5668 5669 // assert headers 5670 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5671 t.Errorf("expect %v, got %v", e, a) 5672 } 5673 5674} 5675 5676func TestInputService10ProtocolTestURIParameterQuerystringParamsHeadersAndJSONBodyCase1(t *testing.T) { 5677 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5678 input := &InputService10TestShapeInputService10TestCaseOperation1Input{ 5679 Ascending: aws.String("true"), 5680 Checksum: aws.String("12345"), 5681 Config: &InputService10TestShapeStructType{ 5682 A: aws.String("one"), 5683 B: aws.String("two"), 5684 }, 5685 PageToken: aws.String("bar"), 5686 PipelineId: aws.String("foo"), 5687 } 5688 req, _ := svc.InputService10TestCaseOperation1Request(input) 5689 r := req.HTTPRequest 5690 5691 // build request 5692 req.Build() 5693 if req.Error != nil { 5694 t.Errorf("expect no error, got %v", req.Error) 5695 } 5696 5697 // assert body 5698 if r.Body == nil { 5699 t.Errorf("expect body not to be nil") 5700 } 5701 body, _ := ioutil.ReadAll(r.Body) 5702 awstesting.AssertJSON(t, `{"Config": {"A": "one", "B": "two"}}`, util.Trim(string(body))) 5703 5704 // assert URL 5705 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?Ascending=true&PageToken=bar", r.URL.String()) 5706 5707 // assert headers 5708 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5709 t.Errorf("expect %v, got %v", e, a) 5710 } 5711 if e, a := "12345", r.Header.Get("x-amz-checksum"); e != a { 5712 t.Errorf("expect %v, got %v", e, a) 5713 } 5714 5715} 5716 5717func TestInputService11ProtocolTestStreamingPayloadCase1(t *testing.T) { 5718 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5719 input := &InputService11TestShapeInputService11TestCaseOperation1Input{ 5720 Body: bytes.NewReader([]byte("contents")), 5721 Checksum: aws.String("foo"), 5722 VaultName: aws.String("name"), 5723 } 5724 req, _ := svc.InputService11TestCaseOperation1Request(input) 5725 r := req.HTTPRequest 5726 5727 // build request 5728 req.Build() 5729 if req.Error != nil { 5730 t.Errorf("expect no error, got %v", req.Error) 5731 } 5732 5733 // assert body 5734 if r.Body == nil { 5735 t.Errorf("expect body not to be nil") 5736 } 5737 body, _ := ioutil.ReadAll(r.Body) 5738 if e, a := "contents", util.Trim(string(body)); e != a { 5739 t.Errorf("expect %v, got %v", e, a) 5740 } 5741 5742 // assert URL 5743 awstesting.AssertURL(t, "https://test/2014-01-01/vaults/name/archives", r.URL.String()) 5744 5745 // assert headers 5746 if e, a := "foo", r.Header.Get("x-amz-sha256-tree-hash"); e != a { 5747 t.Errorf("expect %v, got %v", e, a) 5748 } 5749 5750} 5751 5752func TestInputService12ProtocolTestSerializeBlobsInBodyCase1(t *testing.T) { 5753 svc := NewInputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5754 input := &InputService12TestShapeInputService12TestCaseOperation1Input{ 5755 Bar: []byte("Blob param"), 5756 Foo: aws.String("foo_name"), 5757 } 5758 req, _ := svc.InputService12TestCaseOperation1Request(input) 5759 r := req.HTTPRequest 5760 5761 // build request 5762 req.Build() 5763 if req.Error != nil { 5764 t.Errorf("expect no error, got %v", req.Error) 5765 } 5766 5767 // assert body 5768 if r.Body == nil { 5769 t.Errorf("expect body not to be nil") 5770 } 5771 body, _ := ioutil.ReadAll(r.Body) 5772 awstesting.AssertJSON(t, `{"Bar": "QmxvYiBwYXJhbQ=="}`, util.Trim(string(body))) 5773 5774 // assert URL 5775 awstesting.AssertURL(t, "https://test/2014-01-01/foo_name", r.URL.String()) 5776 5777 // assert headers 5778 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5779 t.Errorf("expect %v, got %v", e, a) 5780 } 5781 5782} 5783 5784func TestInputService13ProtocolTestBlobPayloadCase1(t *testing.T) { 5785 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5786 input := &InputService13TestShapeInputService13TestCaseOperation1Input{ 5787 Foo: []byte("bar"), 5788 } 5789 req, _ := svc.InputService13TestCaseOperation1Request(input) 5790 r := req.HTTPRequest 5791 5792 // build request 5793 req.Build() 5794 if req.Error != nil { 5795 t.Errorf("expect no error, got %v", req.Error) 5796 } 5797 5798 // assert body 5799 if r.Body == nil { 5800 t.Errorf("expect body not to be nil") 5801 } 5802 body, _ := ioutil.ReadAll(r.Body) 5803 if e, a := "bar", util.Trim(string(body)); e != a { 5804 t.Errorf("expect %v, got %v", e, a) 5805 } 5806 5807 // assert URL 5808 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5809 5810 // assert headers 5811 5812} 5813 5814func TestInputService13ProtocolTestBlobPayloadCase2(t *testing.T) { 5815 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5816 input := &InputService13TestShapeInputService13TestCaseOperation2Input{} 5817 req, _ := svc.InputService13TestCaseOperation2Request(input) 5818 r := req.HTTPRequest 5819 5820 // build request 5821 req.Build() 5822 if req.Error != nil { 5823 t.Errorf("expect no error, got %v", req.Error) 5824 } 5825 5826 // assert URL 5827 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5828 5829 // assert headers 5830 5831} 5832 5833func TestInputService14ProtocolTestStructurePayloadCase1(t *testing.T) { 5834 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5835 input := &InputService14TestShapeInputService14TestCaseOperation1Input{ 5836 Foo: &InputService14TestShapeFooShape{ 5837 Baz: aws.String("bar"), 5838 }, 5839 } 5840 req, _ := svc.InputService14TestCaseOperation1Request(input) 5841 r := req.HTTPRequest 5842 5843 // build request 5844 req.Build() 5845 if req.Error != nil { 5846 t.Errorf("expect no error, got %v", req.Error) 5847 } 5848 5849 // assert body 5850 if r.Body == nil { 5851 t.Errorf("expect body not to be nil") 5852 } 5853 body, _ := ioutil.ReadAll(r.Body) 5854 awstesting.AssertJSON(t, `{"baz": "bar"}`, util.Trim(string(body))) 5855 5856 // assert URL 5857 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5858 5859 // assert headers 5860 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5861 t.Errorf("expect %v, got %v", e, a) 5862 } 5863 5864} 5865 5866func TestInputService14ProtocolTestStructurePayloadCase2(t *testing.T) { 5867 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5868 input := &InputService14TestShapeInputService14TestCaseOperation2Input{} 5869 req, _ := svc.InputService14TestCaseOperation2Request(input) 5870 r := req.HTTPRequest 5871 5872 // build request 5873 req.Build() 5874 if req.Error != nil { 5875 t.Errorf("expect no error, got %v", req.Error) 5876 } 5877 5878 // assert URL 5879 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5880 5881 // assert headers 5882 5883} 5884 5885func TestInputService15ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t *testing.T) { 5886 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5887 input := &InputService15TestShapeInputService15TestCaseOperation1Input{} 5888 req, _ := svc.InputService15TestCaseOperation1Request(input) 5889 r := req.HTTPRequest 5890 5891 // build request 5892 req.Build() 5893 if req.Error != nil { 5894 t.Errorf("expect no error, got %v", req.Error) 5895 } 5896 5897 // assert URL 5898 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5899 5900 // assert headers 5901 5902} 5903 5904func TestInputService15ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t *testing.T) { 5905 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5906 input := &InputService15TestShapeInputService15TestCaseOperation2Input{ 5907 Foo: aws.String(""), 5908 } 5909 req, _ := svc.InputService15TestCaseOperation2Request(input) 5910 r := req.HTTPRequest 5911 5912 // build request 5913 req.Build() 5914 if req.Error != nil { 5915 t.Errorf("expect no error, got %v", req.Error) 5916 } 5917 5918 // assert URL 5919 awstesting.AssertURL(t, "https://test/path?abc=mno¶m-name=", r.URL.String()) 5920 5921 // assert headers 5922 5923} 5924 5925func TestInputService16ProtocolTestRecursiveShapesCase1(t *testing.T) { 5926 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5927 input := &InputService16TestShapeInputService16TestCaseOperation1Input{ 5928 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5929 NoRecurse: aws.String("foo"), 5930 }, 5931 } 5932 req, _ := svc.InputService16TestCaseOperation1Request(input) 5933 r := req.HTTPRequest 5934 5935 // build request 5936 req.Build() 5937 if req.Error != nil { 5938 t.Errorf("expect no error, got %v", req.Error) 5939 } 5940 5941 // assert body 5942 if r.Body == nil { 5943 t.Errorf("expect body not to be nil") 5944 } 5945 body, _ := ioutil.ReadAll(r.Body) 5946 awstesting.AssertJSON(t, `{"RecursiveStruct": {"NoRecurse": "foo"}}`, util.Trim(string(body))) 5947 5948 // assert URL 5949 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5950 5951 // assert headers 5952 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5953 t.Errorf("expect %v, got %v", e, a) 5954 } 5955 5956} 5957 5958func TestInputService16ProtocolTestRecursiveShapesCase2(t *testing.T) { 5959 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5960 input := &InputService16TestShapeInputService16TestCaseOperation2Input{ 5961 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5962 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5963 NoRecurse: aws.String("foo"), 5964 }, 5965 }, 5966 } 5967 req, _ := svc.InputService16TestCaseOperation2Request(input) 5968 r := req.HTTPRequest 5969 5970 // build request 5971 req.Build() 5972 if req.Error != nil { 5973 t.Errorf("expect no error, got %v", req.Error) 5974 } 5975 5976 // assert body 5977 if r.Body == nil { 5978 t.Errorf("expect body not to be nil") 5979 } 5980 body, _ := ioutil.ReadAll(r.Body) 5981 awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveStruct": {"NoRecurse": "foo"}}}`, util.Trim(string(body))) 5982 5983 // assert URL 5984 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5985 5986 // assert headers 5987 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 5988 t.Errorf("expect %v, got %v", e, a) 5989 } 5990 5991} 5992 5993func TestInputService16ProtocolTestRecursiveShapesCase3(t *testing.T) { 5994 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5995 input := &InputService16TestShapeInputService16TestCaseOperation3Input{ 5996 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5997 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5998 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 5999 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 6000 NoRecurse: aws.String("foo"), 6001 }, 6002 }, 6003 }, 6004 }, 6005 } 6006 req, _ := svc.InputService16TestCaseOperation3Request(input) 6007 r := req.HTTPRequest 6008 6009 // build request 6010 req.Build() 6011 if req.Error != nil { 6012 t.Errorf("expect no error, got %v", req.Error) 6013 } 6014 6015 // assert body 6016 if r.Body == nil { 6017 t.Errorf("expect body not to be nil") 6018 } 6019 body, _ := ioutil.ReadAll(r.Body) 6020 awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveStruct": {"RecursiveStruct": {"RecursiveStruct": {"NoRecurse": "foo"}}}}}`, util.Trim(string(body))) 6021 6022 // assert URL 6023 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6024 6025 // assert headers 6026 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6027 t.Errorf("expect %v, got %v", e, a) 6028 } 6029 6030} 6031 6032func TestInputService16ProtocolTestRecursiveShapesCase4(t *testing.T) { 6033 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6034 input := &InputService16TestShapeInputService16TestCaseOperation4Input{ 6035 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 6036 RecursiveList: []*InputService16TestShapeRecursiveStructType{ 6037 { 6038 NoRecurse: aws.String("foo"), 6039 }, 6040 { 6041 NoRecurse: aws.String("bar"), 6042 }, 6043 }, 6044 }, 6045 } 6046 req, _ := svc.InputService16TestCaseOperation4Request(input) 6047 r := req.HTTPRequest 6048 6049 // build request 6050 req.Build() 6051 if req.Error != nil { 6052 t.Errorf("expect no error, got %v", req.Error) 6053 } 6054 6055 // assert body 6056 if r.Body == nil { 6057 t.Errorf("expect body not to be nil") 6058 } 6059 body, _ := ioutil.ReadAll(r.Body) 6060 awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveList": [{"NoRecurse": "foo"}, {"NoRecurse": "bar"}]}}`, util.Trim(string(body))) 6061 6062 // assert URL 6063 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6064 6065 // assert headers 6066 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6067 t.Errorf("expect %v, got %v", e, a) 6068 } 6069 6070} 6071 6072func TestInputService16ProtocolTestRecursiveShapesCase5(t *testing.T) { 6073 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6074 input := &InputService16TestShapeInputService16TestCaseOperation5Input{ 6075 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 6076 RecursiveList: []*InputService16TestShapeRecursiveStructType{ 6077 { 6078 NoRecurse: aws.String("foo"), 6079 }, 6080 { 6081 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 6082 NoRecurse: aws.String("bar"), 6083 }, 6084 }, 6085 }, 6086 }, 6087 } 6088 req, _ := svc.InputService16TestCaseOperation5Request(input) 6089 r := req.HTTPRequest 6090 6091 // build request 6092 req.Build() 6093 if req.Error != nil { 6094 t.Errorf("expect no error, got %v", req.Error) 6095 } 6096 6097 // assert body 6098 if r.Body == nil { 6099 t.Errorf("expect body not to be nil") 6100 } 6101 body, _ := ioutil.ReadAll(r.Body) 6102 awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveList": [{"NoRecurse": "foo"}, {"RecursiveStruct": {"NoRecurse": "bar"}}]}}`, util.Trim(string(body))) 6103 6104 // assert URL 6105 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6106 6107 // assert headers 6108 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6109 t.Errorf("expect %v, got %v", e, a) 6110 } 6111 6112} 6113 6114func TestInputService16ProtocolTestRecursiveShapesCase6(t *testing.T) { 6115 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6116 input := &InputService16TestShapeInputService16TestCaseOperation6Input{ 6117 RecursiveStruct: &InputService16TestShapeRecursiveStructType{ 6118 RecursiveMap: map[string]*InputService16TestShapeRecursiveStructType{ 6119 "bar": { 6120 NoRecurse: aws.String("bar"), 6121 }, 6122 "foo": { 6123 NoRecurse: aws.String("foo"), 6124 }, 6125 }, 6126 }, 6127 } 6128 req, _ := svc.InputService16TestCaseOperation6Request(input) 6129 r := req.HTTPRequest 6130 6131 // build request 6132 req.Build() 6133 if req.Error != nil { 6134 t.Errorf("expect no error, got %v", req.Error) 6135 } 6136 6137 // assert body 6138 if r.Body == nil { 6139 t.Errorf("expect body not to be nil") 6140 } 6141 body, _ := ioutil.ReadAll(r.Body) 6142 awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveMap": {"foo": {"NoRecurse": "foo"}, "bar": {"NoRecurse": "bar"}}}}`, util.Trim(string(body))) 6143 6144 // assert URL 6145 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6146 6147 // assert headers 6148 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6149 t.Errorf("expect %v, got %v", e, a) 6150 } 6151 6152} 6153 6154func TestInputService17ProtocolTestTimestampValuesCase1(t *testing.T) { 6155 svc := NewInputService17ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6156 input := &InputService17TestShapeInputService17TestCaseOperation1Input{ 6157 TimeArg: aws.Time(time.Unix(1422172800, 0)), 6158 TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)), 6159 TimeArgInQuery: aws.Time(time.Unix(1422172800, 0)), 6160 TimeCustom: aws.Time(time.Unix(1422172800, 0)), 6161 TimeCustomInHeader: aws.Time(time.Unix(1422172800, 0)), 6162 TimeCustomInQuery: aws.Time(time.Unix(1422172800, 0)), 6163 TimeFormat: aws.Time(time.Unix(1422172800, 0)), 6164 TimeFormatInHeader: aws.Time(time.Unix(1422172800, 0)), 6165 TimeFormatInQuery: aws.Time(time.Unix(1422172800, 0)), 6166 } 6167 req, _ := svc.InputService17TestCaseOperation1Request(input) 6168 r := req.HTTPRequest 6169 6170 // build request 6171 req.Build() 6172 if req.Error != nil { 6173 t.Errorf("expect no error, got %v", req.Error) 6174 } 6175 6176 // assert body 6177 if r.Body == nil { 6178 t.Errorf("expect body not to be nil") 6179 } 6180 body, _ := ioutil.ReadAll(r.Body) 6181 awstesting.AssertJSON(t, `{"TimeArg": 1422172800, "TimeCustom": "2015-01-25T08:00:00Z", "TimeFormat": "Sun, 25 Jan 2015 08:00:00 GMT"}`, util.Trim(string(body))) 6182 6183 // assert URL 6184 awstesting.AssertURL(t, "https://test/path?TimeQuery=2015-01-25T08%3A00%3A00Z&TimeCustomQuery=1422172800&TimeFormatQuery=1422172800", r.URL.String()) 6185 6186 // assert headers 6187 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6188 t.Errorf("expect %v, got %v", e, a) 6189 } 6190 if e, a := "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg"); e != a { 6191 t.Errorf("expect %v, got %v", e, a) 6192 } 6193 if e, a := "1422172800", r.Header.Get("x-amz-timecustom-header"); e != a { 6194 t.Errorf("expect %v, got %v", e, a) 6195 } 6196 if e, a := "1422172800", r.Header.Get("x-amz-timeformat-header"); e != a { 6197 t.Errorf("expect %v, got %v", e, a) 6198 } 6199 6200} 6201 6202func TestInputService18ProtocolTestNamedLocationsInJSONBodyCase1(t *testing.T) { 6203 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6204 input := &InputService18TestShapeInputService18TestCaseOperation1Input{ 6205 TimeArg: aws.Time(time.Unix(1422172800, 0)), 6206 } 6207 req, _ := svc.InputService18TestCaseOperation1Request(input) 6208 r := req.HTTPRequest 6209 6210 // build request 6211 req.Build() 6212 if req.Error != nil { 6213 t.Errorf("expect no error, got %v", req.Error) 6214 } 6215 6216 // assert body 6217 if r.Body == nil { 6218 t.Errorf("expect body not to be nil") 6219 } 6220 body, _ := ioutil.ReadAll(r.Body) 6221 awstesting.AssertJSON(t, `{"timestamp_location": 1422172800}`, util.Trim(string(body))) 6222 6223 // assert URL 6224 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6225 6226 // assert headers 6227 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6228 t.Errorf("expect %v, got %v", e, a) 6229 } 6230 6231} 6232 6233func TestInputService19ProtocolTestStringPayloadCase1(t *testing.T) { 6234 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6235 input := &InputService19TestShapeInputService19TestCaseOperation1Input{ 6236 Foo: aws.String("bar"), 6237 } 6238 req, _ := svc.InputService19TestCaseOperation1Request(input) 6239 r := req.HTTPRequest 6240 6241 // build request 6242 req.Build() 6243 if req.Error != nil { 6244 t.Errorf("expect no error, got %v", req.Error) 6245 } 6246 6247 // assert body 6248 if r.Body == nil { 6249 t.Errorf("expect body not to be nil") 6250 } 6251 body, _ := ioutil.ReadAll(r.Body) 6252 if e, a := "bar", util.Trim(string(body)); e != a { 6253 t.Errorf("expect %v, got %v", e, a) 6254 } 6255 6256 // assert URL 6257 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6258 6259 // assert headers 6260 6261} 6262 6263func TestInputService20ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 6264 svc := NewInputService20ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6265 input := &InputService20TestShapeInputService20TestCaseOperation1Input{ 6266 Token: aws.String("abc123"), 6267 } 6268 req, _ := svc.InputService20TestCaseOperation1Request(input) 6269 r := req.HTTPRequest 6270 6271 // build request 6272 req.Build() 6273 if req.Error != nil { 6274 t.Errorf("expect no error, got %v", req.Error) 6275 } 6276 6277 // assert body 6278 if r.Body == nil { 6279 t.Errorf("expect body not to be nil") 6280 } 6281 body, _ := ioutil.ReadAll(r.Body) 6282 awstesting.AssertJSON(t, `{"Token": "abc123"}`, util.Trim(string(body))) 6283 6284 // assert URL 6285 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6286 6287 // assert headers 6288 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6289 t.Errorf("expect %v, got %v", e, a) 6290 } 6291 6292} 6293 6294func TestInputService20ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 6295 svc := NewInputService20ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6296 input := &InputService20TestShapeInputService20TestCaseOperation2Input{} 6297 req, _ := svc.InputService20TestCaseOperation2Request(input) 6298 r := req.HTTPRequest 6299 6300 // build request 6301 req.Build() 6302 if req.Error != nil { 6303 t.Errorf("expect no error, got %v", req.Error) 6304 } 6305 6306 // assert body 6307 if r.Body == nil { 6308 t.Errorf("expect body not to be nil") 6309 } 6310 body, _ := ioutil.ReadAll(r.Body) 6311 awstesting.AssertJSON(t, `{"Token": "00000000-0000-4000-8000-000000000000"}`, util.Trim(string(body))) 6312 6313 // assert URL 6314 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6315 6316 // assert headers 6317 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6318 t.Errorf("expect %v, got %v", e, a) 6319 } 6320 6321} 6322 6323func TestInputService21ProtocolTestJSONValueTraitCase1(t *testing.T) { 6324 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6325 input := &InputService21TestShapeInputService21TestCaseOperation1Input{ 6326 Body: &InputService21TestShapeBodyStructure{ 6327 BodyField: func() aws.JSONValue { 6328 var m aws.JSONValue 6329 if err := json.Unmarshal([]byte("{\"Foo\":\"Bar\"}"), &m); err != nil { 6330 panic("failed to unmarshal JSONValue, " + err.Error()) 6331 } 6332 return m 6333 }(), 6334 }, 6335 } 6336 input.HeaderField = aws.JSONValue{"Foo": "Bar"} 6337 input.QueryField = aws.JSONValue{"Foo": "Bar"} 6338 req, _ := svc.InputService21TestCaseOperation1Request(input) 6339 r := req.HTTPRequest 6340 6341 // build request 6342 req.Build() 6343 if req.Error != nil { 6344 t.Errorf("expect no error, got %v", req.Error) 6345 } 6346 6347 // assert body 6348 if r.Body == nil { 6349 t.Errorf("expect body not to be nil") 6350 } 6351 body, _ := ioutil.ReadAll(r.Body) 6352 awstesting.AssertJSON(t, `{"BodyField":"{\"Foo\":\"Bar\"}"}`, util.Trim(string(body))) 6353 6354 // assert URL 6355 awstesting.AssertURL(t, "https://test/?Bar=%7B%22Foo%22%3A%22Bar%22%7D", r.URL.String()) 6356 6357 // assert headers 6358 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6359 t.Errorf("expect %v, got %v", e, a) 6360 } 6361 if e, a := "eyJGb28iOiJCYXIifQ==", r.Header.Get("X-Amz-Foo"); e != a { 6362 t.Errorf("expect %v, got %v", e, a) 6363 } 6364 6365} 6366 6367func TestInputService21ProtocolTestJSONValueTraitCase2(t *testing.T) { 6368 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6369 input := &InputService21TestShapeInputService21TestCaseOperation2Input{ 6370 Body: &InputService21TestShapeBodyStructure{ 6371 BodyListField: []aws.JSONValue{ 6372 func() aws.JSONValue { 6373 var m aws.JSONValue 6374 if err := json.Unmarshal([]byte("{\"Foo\":\"Bar\"}"), &m); err != nil { 6375 panic("failed to unmarshal JSONValue, " + err.Error()) 6376 } 6377 return m 6378 }(), 6379 }, 6380 }, 6381 } 6382 req, _ := svc.InputService21TestCaseOperation2Request(input) 6383 r := req.HTTPRequest 6384 6385 // build request 6386 req.Build() 6387 if req.Error != nil { 6388 t.Errorf("expect no error, got %v", req.Error) 6389 } 6390 6391 // assert body 6392 if r.Body == nil { 6393 t.Errorf("expect body not to be nil") 6394 } 6395 body, _ := ioutil.ReadAll(r.Body) 6396 awstesting.AssertJSON(t, `{"BodyListField":["{\"Foo\":\"Bar\"}"]}`, util.Trim(string(body))) 6397 6398 // assert URL 6399 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6400 6401 // assert headers 6402 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6403 t.Errorf("expect %v, got %v", e, a) 6404 } 6405 6406} 6407 6408func TestInputService21ProtocolTestJSONValueTraitCase3(t *testing.T) { 6409 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6410 input := &InputService21TestShapeInputService21TestCaseOperation3Input{} 6411 req, _ := svc.InputService21TestCaseOperation3Request(input) 6412 r := req.HTTPRequest 6413 6414 // build request 6415 req.Build() 6416 if req.Error != nil { 6417 t.Errorf("expect no error, got %v", req.Error) 6418 } 6419 6420 // assert URL 6421 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6422 6423 // assert headers 6424 6425} 6426 6427func TestInputService22ProtocolTestEnumCase1(t *testing.T) { 6428 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6429 input := &InputService22TestShapeInputService22TestCaseOperation1Input{ 6430 FooEnum: aws.String("foo"), 6431 HeaderEnum: aws.String("baz"), 6432 ListEnums: []*string{ 6433 aws.String("foo"), 6434 aws.String(""), 6435 aws.String("bar"), 6436 }, 6437 QueryFooEnum: aws.String("bar"), 6438 QueryListEnums: []*string{ 6439 aws.String("0"), 6440 aws.String("1"), 6441 aws.String(""), 6442 }, 6443 } 6444 req, _ := svc.InputService22TestCaseOperation1Request(input) 6445 r := req.HTTPRequest 6446 6447 // build request 6448 req.Build() 6449 if req.Error != nil { 6450 t.Errorf("expect no error, got %v", req.Error) 6451 } 6452 6453 // assert body 6454 if r.Body == nil { 6455 t.Errorf("expect body not to be nil") 6456 } 6457 body, _ := ioutil.ReadAll(r.Body) 6458 awstesting.AssertJSON(t, `{"FooEnum": "foo", "ListEnums": ["foo", "", "bar"]}`, util.Trim(string(body))) 6459 6460 // assert URL 6461 awstesting.AssertURL(t, "https://test/path?Enum=bar&List=0&List=1&List=", r.URL.String()) 6462 6463 // assert headers 6464 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6465 t.Errorf("expect %v, got %v", e, a) 6466 } 6467 if e, a := "baz", r.Header.Get("x-amz-enum"); e != a { 6468 t.Errorf("expect %v, got %v", e, a) 6469 } 6470 6471} 6472 6473func TestInputService22ProtocolTestEnumCase2(t *testing.T) { 6474 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6475 input := &InputService22TestShapeInputService22TestCaseOperation2Input{} 6476 req, _ := svc.InputService22TestCaseOperation2Request(input) 6477 r := req.HTTPRequest 6478 6479 // build request 6480 req.Build() 6481 if req.Error != nil { 6482 t.Errorf("expect no error, got %v", req.Error) 6483 } 6484 6485 // assert URL 6486 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6487 6488 // assert headers 6489 6490} 6491 6492func TestInputService23ProtocolTestEndpointHostTraitCase1(t *testing.T) { 6493 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 6494 input := &InputService23TestShapeInputService23TestCaseOperation1Input{ 6495 Name: aws.String("myname"), 6496 } 6497 req, _ := svc.InputService23TestCaseOperation1Request(input) 6498 r := req.HTTPRequest 6499 6500 // build request 6501 req.Build() 6502 if req.Error != nil { 6503 t.Errorf("expect no error, got %v", req.Error) 6504 } 6505 6506 // assert body 6507 if r.Body == nil { 6508 t.Errorf("expect body not to be nil") 6509 } 6510 body, _ := ioutil.ReadAll(r.Body) 6511 awstesting.AssertJSON(t, `{"Name": "myname"}`, util.Trim(string(body))) 6512 6513 // assert URL 6514 awstesting.AssertURL(t, "https://data-service.region.amazonaws.com/path", r.URL.String()) 6515 6516 // assert headers 6517 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6518 t.Errorf("expect %v, got %v", e, a) 6519 } 6520 6521} 6522 6523func TestInputService23ProtocolTestEndpointHostTraitCase2(t *testing.T) { 6524 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 6525 input := &InputService23TestShapeInputService23TestCaseOperation2Input{ 6526 Name: aws.String("myname"), 6527 } 6528 req, _ := svc.InputService23TestCaseOperation2Request(input) 6529 r := req.HTTPRequest 6530 6531 // build request 6532 req.Build() 6533 if req.Error != nil { 6534 t.Errorf("expect no error, got %v", req.Error) 6535 } 6536 6537 // assert body 6538 if r.Body == nil { 6539 t.Errorf("expect body not to be nil") 6540 } 6541 body, _ := ioutil.ReadAll(r.Body) 6542 awstesting.AssertJSON(t, `{"Name": "myname"}`, util.Trim(string(body))) 6543 6544 // assert URL 6545 awstesting.AssertURL(t, "https://foo-myname.service.region.amazonaws.com/path", r.URL.String()) 6546 6547 // assert headers 6548 if e, a := "application/json", r.Header.Get("Content-Type"); e != a { 6549 t.Errorf("expect %v, got %v", e, a) 6550 } 6551 6552} 6553 6554func TestInputService24ProtocolTestHeaderWhitespaceCase1(t *testing.T) { 6555 svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6556 input := &InputService24TestShapeInputService24TestCaseOperation1Input{ 6557 Header1: aws.String(" headerValue"), 6558 HeaderMap: map[string]*string{ 6559 " key-leading-space": aws.String("value"), 6560 " key-with-space ": aws.String("value"), 6561 "leading-space": aws.String(" value"), 6562 "leading-tab": aws.String(" value"), 6563 "with-space": aws.String(" value "), 6564 }, 6565 } 6566 req, _ := svc.InputService24TestCaseOperation1Request(input) 6567 r := req.HTTPRequest 6568 6569 // build request 6570 req.Build() 6571 if req.Error != nil { 6572 t.Errorf("expect no error, got %v", req.Error) 6573 } 6574 6575 // assert URL 6576 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6577 6578 // assert headers 6579 if e, a := "value", r.Header.Get("header-map-key-leading-space"); e != a { 6580 t.Errorf("expect %v, got %v", e, a) 6581 } 6582 if e, a := "value", r.Header.Get("header-map-key-with-space"); e != a { 6583 t.Errorf("expect %v, got %v", e, a) 6584 } 6585 if e, a := "value", r.Header.Get("header-map-leading-space"); e != a { 6586 t.Errorf("expect %v, got %v", e, a) 6587 } 6588 if e, a := "value", r.Header.Get("header-map-leading-tab"); e != a { 6589 t.Errorf("expect %v, got %v", e, a) 6590 } 6591 if e, a := "value", r.Header.Get("header-map-with-space"); e != a { 6592 t.Errorf("expect %v, got %v", e, a) 6593 } 6594 if e, a := "headerValue", r.Header.Get("header1"); e != a { 6595 t.Errorf("expect %v, got %v", e, a) 6596 } 6597 6598} 6599