vincent/aptly
1
0
Fork 0
mirror of https://github.com/aptly-dev/aptly.git synced 2026-05-06 22:18:28 +00:00
Code Issues Projects Releases Wiki Activity

Upgrade AWS SDK to the latest version

Browse Source
This commit is contained in:
Andrey Smirnov
2017-09-28 17:57:05 +03:00
parent 9a767b7631
commit 182c21e38c
1096 changed files with 309697 additions and 132612 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_test.go
Generated Vendored
+160 -134
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opInputService1TestCaseOperation1 = "OperationName"
// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService1TestCaseOperation1 method directly
// instead.
// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService1TestCaseOperation1Request method.
// req, resp := client.InputService1TestCaseOperation1Request(params)
@@ -195,8 +198,12 @@ type InputService1TestShapeInputService1TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService2ProtocolTest struct {
*client.Client
}
@@ -254,19 +261,18 @@ const opInputService2TestCaseOperation1 = "OperationName"
// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService2TestCaseOperation1 method directly
// instead.
// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService2TestCaseOperation1Request method.
// req, resp := client.InputService2TestCaseOperation1Request(params)
@@ -353,8 +359,12 @@ type InputService2TestShapeInputService2TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService3ProtocolTest struct {
*client.Client
}
@@ -412,19 +422,18 @@ const opInputService3TestCaseOperation1 = "OperationName"
// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService3TestCaseOperation1 method directly
// instead.
// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService3TestCaseOperation1Request method.
// req, resp := client.InputService3TestCaseOperation1Request(params)
@@ -507,8 +516,12 @@ func (s *InputService3TestShapeStructType) SetScalarArg(v string) *InputService3
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService4ProtocolTest struct {
*client.Client
}
@@ -566,19 +579,18 @@ const opInputService4TestCaseOperation1 = "OperationName"
// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService4TestCaseOperation1 method directly
// instead.
// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService4TestCaseOperation1Request method.
// req, resp := client.InputService4TestCaseOperation1Request(params)
@@ -649,8 +661,12 @@ type InputService4TestShapeInputService4TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService5ProtocolTest struct {
*client.Client
}
@@ -708,19 +724,18 @@ const opInputService5TestCaseOperation1 = "OperationName"
// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation1 method directly
// instead.
// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation1Request method.
// req, resp := client.InputService5TestCaseOperation1Request(params)
@@ -791,8 +806,12 @@ type InputService5TestShapeInputService5TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService6ProtocolTest struct {
*client.Client
}
@@ -850,19 +869,18 @@ const opInputService6TestCaseOperation1 = "OperationName"
// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService6TestCaseOperation1 method directly
// instead.
// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService6TestCaseOperation1Request method.
// req, resp := client.InputService6TestCaseOperation1Request(params)
@@ -933,8 +951,12 @@ type InputService6TestShapeInputService6TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService7ProtocolTest struct {
*client.Client
}
@@ -992,19 +1014,18 @@ const opInputService7TestCaseOperation1 = "OperationName"
// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService7TestCaseOperation1 method directly
// instead.
// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService7TestCaseOperation1Request method.
// req, resp := client.InputService7TestCaseOperation1Request(params)
@@ -1076,8 +1097,12 @@ type InputService7TestShapeInputService7TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService8ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService8ProtocolTest struct {
*client.Client
}
@@ -1135,19 +1160,18 @@ const opInputService8TestCaseOperation1 = "OperationName"
// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService8TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService8TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService8TestCaseOperation1 method directly
// instead.
// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService8TestCaseOperation1Request method.
// req, resp := client.InputService8TestCaseOperation1Request(params)
@@ -1218,8 +1242,12 @@ type InputService8TestShapeInputService8TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService9ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService9ProtocolTest struct {
*client.Client
}
@@ -1277,19 +1305,18 @@ const opInputService9TestCaseOperation1 = "OperationName"
// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService9TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService9TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService9TestCaseOperation1 method directly
// instead.
// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService9TestCaseOperation1Request method.
// req, resp := client.InputService9TestCaseOperation1Request(params)
@@ -1298,14 +1325,14 @@ const opInputService9TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputShape) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
op := &request.Operation{
Name: opInputService9TestCaseOperation1,
HTTPPath: "/",
}
if input == nil {
input = &InputService9TestShapeInputShape{}
input = &InputService9TestShapeInputService9TestCaseOperation2Input{}
}
output = &InputService9TestShapeInputService9TestCaseOperation1Output{}
@@ -1323,7 +1350,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input
//
// See the AWS API reference guide for 's
// API operation InputService9TestCaseOperation1 for usage and error information.
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputShape) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
req, out := c.InputService9TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -1337,7 +1364,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputShape, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) {
req, out := c.InputService9TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1348,19 +1375,18 @@ const opInputService9TestCaseOperation2 = "OperationName"
// InputService9TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the InputService9TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService9TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService9TestCaseOperation2 method directly
// instead.
// See InputService9TestCaseOperation2 for more information on using the InputService9TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService9TestCaseOperation2Request method.
// req, resp := client.InputService9TestCaseOperation2Request(params)
@@ -1369,14 +1395,14 @@ const opInputService9TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputShape) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) {
op := &request.Operation{
Name: opInputService9TestCaseOperation2,
HTTPPath: "/",
}
if input == nil {
input = &InputService9TestShapeInputShape{}
input = &InputService9TestShapeInputService9TestCaseOperation2Input{}
}
output = &InputService9TestShapeInputService9TestCaseOperation2Output{}
@@ -1394,7 +1420,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input
//
// See the AWS API reference guide for 's
// API operation InputService9TestCaseOperation2 for usage and error information.
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputShape) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
req, out := c.InputService9TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -1408,7 +1434,7 @@ func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputShape, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) {
req, out := c.InputService9TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1419,22 +1445,22 @@ type InputService9TestShapeInputService9TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
type InputService9TestShapeInputService9TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
type InputService9TestShapeInputShape struct {
type InputService9TestShapeInputService9TestCaseOperation2Input struct {
_ struct{} `type:"structure"`
Token *string `type:"string" idempotencyToken:"true"`
}
// SetToken sets the Token field's value.
func (s *InputService9TestShapeInputShape) SetToken(v string) *InputService9TestShapeInputShape {
func (s *InputService9TestShapeInputService9TestCaseOperation2Input) SetToken(v string) *InputService9TestShapeInputService9TestCaseOperation2Input {
s.Token = &v
return s
}
type InputService9TestShapeInputService9TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
//
// Tests begin here
//
@@ -1650,7 +1676,7 @@ func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService9TestShapeInputShape{
input := &InputService9TestShapeInputService9TestCaseOperation2Input{
Token: aws.String("abc123"),
}
req, _ := svc.InputService9TestCaseOperation1Request(input)
@@ -1674,7 +1700,7 @@ func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) {
svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService9TestShapeInputShape{}
input := &InputService9TestShapeInputService9TestCaseOperation2Input{}
req, _ := svc.InputService9TestCaseOperation2Request(input)
r := req.HTTPRequest
vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal_test.go
Generated Vendored
+135 -108
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation1 method directly
// instead.
// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation1Request method.
// req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -241,8 +244,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService2ProtocolTest struct {
*client.Client
}
@@ -300,19 +307,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService2TestCaseOperation1 method directly
// instead.
// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService2TestCaseOperation1Request method.
// req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -382,8 +388,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService3ProtocolTest struct {
*client.Client
}
@@ -441,19 +451,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService3TestCaseOperation1 method directly
// instead.
// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService3TestCaseOperation1Request method.
// req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -522,8 +531,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService4ProtocolTest struct {
*client.Client
}
@@ -581,19 +594,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation1 method directly
// instead.
// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation1Request method.
// req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -662,8 +674,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService5ProtocolTest struct {
*client.Client
}
@@ -721,19 +737,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService5TestCaseOperation1 method directly
// instead.
// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService5TestCaseOperation1Request method.
// req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -802,8 +817,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService6ProtocolTest struct {
*client.Client
}
@@ -861,19 +880,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService6TestCaseOperation1 method directly
// instead.
// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService6TestCaseOperation1Request method.
// req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -954,8 +972,12 @@ func (s *OutputService6TestShapeStructureType) SetFoo(v string) *OutputService6T
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService7ProtocolTest struct {
*client.Client
}
@@ -1013,19 +1035,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
// OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService7TestCaseOperation1 method directly
// instead.
// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService7TestCaseOperation1Request method.
// req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1094,8 +1115,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService8ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService8ProtocolTest struct {
*client.Client
}
@@ -1153,19 +1178,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
// OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService8TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService8TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService8TestCaseOperation1 method directly
// instead.
// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService8TestCaseOperation1Request method.
// req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1234,8 +1258,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService9ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService9ProtocolTest struct {
*client.Client
}
@@ -1293,19 +1321,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
// OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService9TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService9TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService9TestCaseOperation1 method directly
// instead.
// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService9TestCaseOperation1Request method.
// req, resp := client.OutputService9TestCaseOperation1Request(params)
vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/build_test.go
Generated Vendored
+237 -223
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService1ProtocolTest struct {
*client.Client
}
@@ -106,19 +110,18 @@ const opInputService1TestCaseOperation1 = "OperationName"
// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService1TestCaseOperation1 method directly
// instead.
// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService1TestCaseOperation1Request method.
// req, resp := client.InputService1TestCaseOperation1Request(params)
@@ -190,8 +193,12 @@ type InputService1TestShapeInputService1TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService2ProtocolTest struct {
*client.Client
}
@@ -251,19 +258,18 @@ const opInputService2TestCaseOperation1 = "OperationName"
// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService2TestCaseOperation1 method directly
// instead.
// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService2TestCaseOperation1Request method.
// req, resp := client.InputService2TestCaseOperation1Request(params)
@@ -334,8 +340,12 @@ type InputService2TestShapeInputService2TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService3ProtocolTest struct {
*client.Client
}
@@ -395,19 +405,18 @@ const opInputService3TestCaseOperation1 = "OperationName"
// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService3TestCaseOperation1 method directly
// instead.
// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService3TestCaseOperation1Request method.
// req, resp := client.InputService3TestCaseOperation1Request(params)
@@ -416,14 +425,14 @@ const opInputService3TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
op := &request.Operation{
Name: opInputService3TestCaseOperation1,
HTTPPath: "/",
}
if input == nil {
input = &InputService3TestShapeInputShape{}
input = &InputService3TestShapeInputService3TestCaseOperation2Input{}
}
output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
@@ -441,7 +450,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input
//
// See the AWS API reference guide for 's
// API operation InputService3TestCaseOperation1 for usage and error information.
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
req, out := c.InputService3TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -455,7 +464,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputShape, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
req, out := c.InputService3TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -466,19 +475,18 @@ const opInputService3TestCaseOperation2 = "OperationName"
// InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the InputService3TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService3TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService3TestCaseOperation2 method directly
// instead.
// See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService3TestCaseOperation2Request method.
// req, resp := client.InputService3TestCaseOperation2Request(params)
@@ -487,14 +495,14 @@ const opInputService3TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputShape) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) {
op := &request.Operation{
Name: opInputService3TestCaseOperation2,
HTTPPath: "/",
}
if input == nil {
input = &InputService3TestShapeInputShape{}
input = &InputService3TestShapeInputService3TestCaseOperation2Input{}
}
output = &InputService3TestShapeInputService3TestCaseOperation2Output{}
@@ -512,7 +520,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input
//
// See the AWS API reference guide for 's
// API operation InputService3TestCaseOperation2 for usage and error information.
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
req, out := c.InputService3TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -526,7 +534,7 @@ func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputShape, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) {
req, out := c.InputService3TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -537,11 +545,7 @@ type InputService3TestShapeInputService3TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
type InputService3TestShapeInputService3TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
type InputService3TestShapeInputShape struct {
type InputService3TestShapeInputService3TestCaseOperation2Input struct {
_ struct{} `type:"structure"`
// BlobArg is automatically base64 encoded/decoded by the SDK.
@@ -551,19 +555,27 @@ type InputService3TestShapeInputShape struct {
}
// SetBlobArg sets the BlobArg field's value.
func (s *InputService3TestShapeInputShape) SetBlobArg(v []byte) *InputService3TestShapeInputShape {
func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobArg(v []byte) *InputService3TestShapeInputService3TestCaseOperation2Input {
s.BlobArg = v
return s
}
// SetBlobMap sets the BlobMap field's value.
func (s *InputService3TestShapeInputShape) SetBlobMap(v map[string][]byte) *InputService3TestShapeInputShape {
func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobMap(v map[string][]byte) *InputService3TestShapeInputService3TestCaseOperation2Input {
s.BlobMap = v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
type InputService3TestShapeInputService3TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
// InputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService4ProtocolTest struct {
*client.Client
}
@@ -623,19 +635,18 @@ const opInputService4TestCaseOperation1 = "OperationName"
// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService4TestCaseOperation1 method directly
// instead.
// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService4TestCaseOperation1Request method.
// req, resp := client.InputService4TestCaseOperation1Request(params)
@@ -707,8 +718,12 @@ type InputService4TestShapeInputService4TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService5ProtocolTest struct {
*client.Client
}
@@ -768,19 +783,18 @@ const opInputService5TestCaseOperation1 = "OperationName"
// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation1 method directly
// instead.
// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation1Request method.
// req, resp := client.InputService5TestCaseOperation1Request(params)
@@ -789,14 +803,14 @@ const opInputService5TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation1,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
@@ -814,7 +828,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation1 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
req, out := c.InputService5TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -828,7 +842,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
req, out := c.InputService5TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -839,19 +853,18 @@ const opInputService5TestCaseOperation2 = "OperationName"
// InputService5TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation2 method directly
// instead.
// See InputService5TestCaseOperation2 for more information on using the InputService5TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation2Request method.
// req, resp := client.InputService5TestCaseOperation2Request(params)
@@ -860,14 +873,14 @@ const opInputService5TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation2Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation2Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation2,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation2Output{}
@@ -885,7 +898,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation2 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
req, out := c.InputService5TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -899,7 +912,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation2WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation2Output, error) {
req, out := c.InputService5TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -910,19 +923,18 @@ const opInputService5TestCaseOperation3 = "OperationName"
// InputService5TestCaseOperation3Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation3 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation3 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation3 method directly
// instead.
// See InputService5TestCaseOperation3 for more information on using the InputService5TestCaseOperation3
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation3Request method.
// req, resp := client.InputService5TestCaseOperation3Request(params)
@@ -931,14 +943,14 @@ const opInputService5TestCaseOperation3 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation3Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation3Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation3,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation3Output{}
@@ -956,7 +968,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation3Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation3 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
req, out := c.InputService5TestCaseOperation3Request(input)
return out, req.Send()
}
@@ -970,7 +982,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation3(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation3WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation3Output, error) {
req, out := c.InputService5TestCaseOperation3Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -981,19 +993,18 @@ const opInputService5TestCaseOperation4 = "OperationName"
// InputService5TestCaseOperation4Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation4 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation4 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation4 method directly
// instead.
// See InputService5TestCaseOperation4 for more information on using the InputService5TestCaseOperation4
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation4Request method.
// req, resp := client.InputService5TestCaseOperation4Request(params)
@@ -1002,14 +1013,14 @@ const opInputService5TestCaseOperation4 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation4Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation4Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation4,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation4Output{}
@@ -1027,7 +1038,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation4Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation4 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
req, out := c.InputService5TestCaseOperation4Request(input)
return out, req.Send()
}
@@ -1041,7 +1052,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation4(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation4WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation4Output, error) {
req, out := c.InputService5TestCaseOperation4Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1052,19 +1063,18 @@ const opInputService5TestCaseOperation5 = "OperationName"
// InputService5TestCaseOperation5Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation5 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation5 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation5 method directly
// instead.
// See InputService5TestCaseOperation5 for more information on using the InputService5TestCaseOperation5
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation5Request method.
// req, resp := client.InputService5TestCaseOperation5Request(params)
@@ -1073,14 +1083,14 @@ const opInputService5TestCaseOperation5 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation5Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation5Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation5,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation5Output{}
@@ -1098,7 +1108,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation5Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation5 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
req, out := c.InputService5TestCaseOperation5Request(input)
return out, req.Send()
}
@@ -1112,7 +1122,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation5(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation5WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation5Output, error) {
req, out := c.InputService5TestCaseOperation5Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1123,19 +1133,18 @@ const opInputService5TestCaseOperation6 = "OperationName"
// InputService5TestCaseOperation6Request generates a "aws/request.Request" representing the
// client's request for the InputService5TestCaseOperation6 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService5TestCaseOperation6 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService5TestCaseOperation6 method directly
// instead.
// See InputService5TestCaseOperation6 for more information on using the InputService5TestCaseOperation6
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService5TestCaseOperation6Request method.
// req, resp := client.InputService5TestCaseOperation6Request(params)
@@ -1144,14 +1153,14 @@ const opInputService5TestCaseOperation6 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input *InputService5TestShapeInputShape) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation6Output) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input *InputService5TestShapeInputService5TestCaseOperation6Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation6Output) {
op := &request.Operation{
Name: opInputService5TestCaseOperation6,
HTTPPath: "/",
}
if input == nil {
input = &InputService5TestShapeInputShape{}
input = &InputService5TestShapeInputService5TestCaseOperation6Input{}
}
output = &InputService5TestShapeInputService5TestCaseOperation6Output{}
@@ -1169,7 +1178,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation6Request(input
//
// See the AWS API reference guide for 's
// API operation InputService5TestCaseOperation6 for usage and error information.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *InputService5TestShapeInputService5TestCaseOperation6Input) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
req, out := c.InputService5TestCaseOperation6Request(input)
return out, req.Send()
}
@@ -1183,7 +1192,7 @@ func (c *InputService5ProtocolTest) InputService5TestCaseOperation6(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6WithContext(ctx aws.Context, input *InputService5TestShapeInputShape, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
func (c *InputService5ProtocolTest) InputService5TestCaseOperation6WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation6Output, error) {
req, out := c.InputService5TestCaseOperation6Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1210,22 +1219,22 @@ type InputService5TestShapeInputService5TestCaseOperation5Output struct {
_ struct{} `type:"structure"`
}
type InputService5TestShapeInputService5TestCaseOperation6Output struct {
_ struct{} `type:"structure"`
}
type InputService5TestShapeInputShape struct {
type InputService5TestShapeInputService5TestCaseOperation6Input struct {
_ struct{} `type:"structure"`
RecursiveStruct *InputService5TestShapeRecursiveStructType `type:"structure"`
}
// SetRecursiveStruct sets the RecursiveStruct field's value.
func (s *InputService5TestShapeInputShape) SetRecursiveStruct(v *InputService5TestShapeRecursiveStructType) *InputService5TestShapeInputShape {
func (s *InputService5TestShapeInputService5TestCaseOperation6Input) SetRecursiveStruct(v *InputService5TestShapeRecursiveStructType) *InputService5TestShapeInputService5TestCaseOperation6Input {
s.RecursiveStruct = v
return s
}
type InputService5TestShapeInputService5TestCaseOperation6Output struct {
_ struct{} `type:"structure"`
}
type InputService5TestShapeRecursiveStructType struct {
_ struct{} `type:"structure"`
@@ -1262,8 +1271,12 @@ func (s *InputService5TestShapeRecursiveStructType) SetRecursiveStruct(v *InputS
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService6ProtocolTest struct {
*client.Client
}
@@ -1323,19 +1336,18 @@ const opInputService6TestCaseOperation1 = "OperationName"
// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService6TestCaseOperation1 method directly
// instead.
// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService6TestCaseOperation1Request method.
// req, resp := client.InputService6TestCaseOperation1Request(params)
@@ -1407,8 +1419,12 @@ type InputService6TestShapeInputService6TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// InputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type InputService7ProtocolTest struct {
*client.Client
}
@@ -1466,19 +1482,18 @@ const opInputService7TestCaseOperation1 = "OperationName"
// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the InputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService7TestCaseOperation1 method directly
// instead.
// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService7TestCaseOperation1Request method.
// req, resp := client.InputService7TestCaseOperation1Request(params)
@@ -1487,7 +1502,7 @@ const opInputService7TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation2Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
op := &request.Operation{
Name: opInputService7TestCaseOperation1,
HTTPMethod: "POST",
@@ -1495,7 +1510,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input
}
if input == nil {
input = &InputService7TestShapeInputShape{}
input = &InputService7TestShapeInputService7TestCaseOperation2Input{}
}
output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
@@ -1513,7 +1528,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input
//
// See the AWS API reference guide for 's
// API operation InputService7TestCaseOperation1 for usage and error information.
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation2Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
req, out := c.InputService7TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -1527,7 +1542,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputShape, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
req, out := c.InputService7TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1538,19 +1553,18 @@ const opInputService7TestCaseOperation2 = "OperationName"
// InputService7TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the InputService7TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See InputService7TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the InputService7TestCaseOperation2 method directly
// instead.
// See InputService7TestCaseOperation2 for more information on using the InputService7TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the InputService7TestCaseOperation2Request method.
// req, resp := client.InputService7TestCaseOperation2Request(params)
@@ -1559,7 +1573,7 @@ const opInputService7TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input *InputService7TestShapeInputShape) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation2Output) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input *InputService7TestShapeInputService7TestCaseOperation2Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation2Output) {
op := &request.Operation{
Name: opInputService7TestCaseOperation2,
HTTPMethod: "POST",
@@ -1567,7 +1581,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input
}
if input == nil {
input = &InputService7TestShapeInputShape{}
input = &InputService7TestShapeInputService7TestCaseOperation2Input{}
}
output = &InputService7TestShapeInputService7TestCaseOperation2Output{}
@@ -1585,7 +1599,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2Request(input
//
// See the AWS API reference guide for 's
// API operation InputService7TestCaseOperation2 for usage and error information.
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *InputService7TestShapeInputService7TestCaseOperation2Input) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
req, out := c.InputService7TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -1599,7 +1613,7 @@ func (c *InputService7ProtocolTest) InputService7TestCaseOperation2(input *Input
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input *InputService7TestShapeInputShape, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
func (c *InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation2Output, error) {
req, out := c.InputService7TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -1610,22 +1624,22 @@ type InputService7TestShapeInputService7TestCaseOperation1Output struct {
_ struct{} `type:"structure"`
}
type InputService7TestShapeInputService7TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
type InputService7TestShapeInputShape struct {
type InputService7TestShapeInputService7TestCaseOperation2Input struct {
_ struct{} `type:"structure"`
Token *string `type:"string" idempotencyToken:"true"`
}
// SetToken sets the Token field's value.
func (s *InputService7TestShapeInputShape) SetToken(v string) *InputService7TestShapeInputShape {
func (s *InputService7TestShapeInputService7TestCaseOperation2Input) SetToken(v string) *InputService7TestShapeInputService7TestCaseOperation2Input {
s.Token = &v
return s
}
type InputService7TestShapeInputService7TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
}
//
// Tests begin here
//
@@ -1684,7 +1698,7 @@ func TestInputService2ProtocolTestTimestampValuesCase1(t *testing.T) {
func TestInputService3ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService3TestShapeInputShape{
input := &InputService3TestShapeInputService3TestCaseOperation2Input{
BlobArg: []byte("foo"),
}
req, _ := svc.InputService3TestCaseOperation1Request(input)
@@ -1710,7 +1724,7 @@ func TestInputService3ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
func TestInputService3ProtocolTestBase64EncodedBlobsCase2(t *testing.T) {
svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService3TestShapeInputShape{
input := &InputService3TestShapeInputService3TestCaseOperation2Input{
BlobMap: map[string][]byte{
"key1": []byte("foo"),
"key2": []byte("bar"),
@@ -1768,7 +1782,7 @@ func TestInputService4ProtocolTestNestedBlobsCase1(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase1(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
NoRecurse: aws.String("foo"),
},
@@ -1796,7 +1810,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase1(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase2(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
NoRecurse: aws.String("foo"),
@@ -1826,7 +1840,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase2(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
@@ -1860,7 +1874,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase4(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveList: []*InputService5TestShapeRecursiveStructType{
{
@@ -1895,7 +1909,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase4(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase5(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveList: []*InputService5TestShapeRecursiveStructType{
{
@@ -1932,7 +1946,7 @@ func TestInputService5ProtocolTestRecursiveShapesCase5(t *testing.T) {
func TestInputService5ProtocolTestRecursiveShapesCase6(t *testing.T) {
svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService5TestShapeInputShape{
input := &InputService5TestShapeInputService5TestCaseOperation6Input{
RecursiveStruct: &InputService5TestShapeRecursiveStructType{
RecursiveMap: map[string]*InputService5TestShapeRecursiveStructType{
"bar": {
@@ -1993,7 +2007,7 @@ func TestInputService6ProtocolTestEmptyMapsCase1(t *testing.T) {
func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService7TestShapeInputShape{
input := &InputService7TestShapeInputService7TestCaseOperation2Input{
Token: aws.String("abc123"),
}
req, _ := svc.InputService7TestCaseOperation1Request(input)
@@ -2017,7 +2031,7 @@ func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) {
func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) {
svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")})
input := &InputService7TestShapeInputShape{}
input := &InputService7TestShapeInputService7TestCaseOperation2Input{}
req, _ := svc.InputService7TestCaseOperation2Request(input)
r := req.HTTPRequest
vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_test.go
Generated Vendored
+111 -94
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation1 method directly
// instead.
// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation1Request method.
// req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -241,8 +244,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService2ProtocolTest struct {
*client.Client
}
@@ -300,19 +307,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService2TestCaseOperation1 method directly
// instead.
// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService2TestCaseOperation1Request method.
// req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -403,8 +409,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStruc
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService3ProtocolTest struct {
*client.Client
}
@@ -462,19 +472,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService3TestCaseOperation1 method directly
// instead.
// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService3TestCaseOperation1Request method.
// req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -563,8 +572,12 @@ func (s *OutputService3TestShapeTimeContainer) SetFoo(v time.Time) *OutputServic
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService4ProtocolTest struct {
*client.Client
}
@@ -622,19 +635,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation1 method directly
// instead.
// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation1Request method.
// req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -643,7 +655,7 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *request.Request, output *OutputService4TestShapeOutputShape) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *request.Request, output *OutputService4TestShapeOutputService4TestCaseOperation2Output) {
op := &request.Operation{
Name: opOutputService4TestCaseOperation1,
HTTPPath: "/",
@@ -653,7 +665,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(inp
input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
}
output = &OutputService4TestShapeOutputShape{}
output = &OutputService4TestShapeOutputService4TestCaseOperation2Output{}
req = c.newRequest(op, input, output)
return
}
@@ -666,7 +678,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(inp
//
// See the AWS API reference guide for 's
// API operation OutputService4TestCaseOperation1 for usage and error information.
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
req, out := c.OutputService4TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -680,7 +692,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *Out
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (*OutputService4TestShapeOutputShape, error) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
req, out := c.OutputService4TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -691,19 +703,18 @@ const opOutputService4TestCaseOperation2 = "OperationName"
// OutputService4TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation2 method directly
// instead.
// See OutputService4TestCaseOperation2 for more information on using the OutputService4TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation2Request method.
// req, resp := client.OutputService4TestCaseOperation2Request(params)
@@ -712,7 +723,7 @@ const opOutputService4TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (req *request.Request, output *OutputService4TestShapeOutputShape) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (req *request.Request, output *OutputService4TestShapeOutputService4TestCaseOperation2Output) {
op := &request.Operation{
Name: opOutputService4TestCaseOperation2,
HTTPPath: "/",
@@ -722,7 +733,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(inp
input = &OutputService4TestShapeOutputService4TestCaseOperation2Input{}
}
output = &OutputService4TestShapeOutputShape{}
output = &OutputService4TestShapeOutputService4TestCaseOperation2Output{}
req = c.newRequest(op, input, output)
return
}
@@ -735,7 +746,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(inp
//
// See the AWS API reference guide for 's
// API operation OutputService4TestCaseOperation2 for usage and error information.
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (*OutputService4TestShapeOutputShape, error) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *OutputService4TestShapeOutputService4TestCaseOperation2Input) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
req, out := c.OutputService4TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -749,7 +760,7 @@ func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2(input *Out
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation2Input, opts ...request.Option) (*OutputService4TestShapeOutputShape, error) {
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation2WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation2Input, opts ...request.Option) (*OutputService4TestShapeOutputService4TestCaseOperation2Output, error) {
req, out := c.OutputService4TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -764,7 +775,7 @@ type OutputService4TestShapeOutputService4TestCaseOperation2Input struct {
_ struct{} `type:"structure"`
}
type OutputService4TestShapeOutputShape struct {
type OutputService4TestShapeOutputService4TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
ListMember []*string `type:"list"`
@@ -775,19 +786,19 @@ type OutputService4TestShapeOutputShape struct {
}
// SetListMember sets the ListMember field's value.
func (s *OutputService4TestShapeOutputShape) SetListMember(v []*string) *OutputService4TestShapeOutputShape {
func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMember(v []*string) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
s.ListMember = v
return s
}
// SetListMemberMap sets the ListMemberMap field's value.
func (s *OutputService4TestShapeOutputShape) SetListMemberMap(v []map[string]*string) *OutputService4TestShapeOutputShape {
func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberMap(v []map[string]*string) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
s.ListMemberMap = v
return s
}
// SetListMemberStruct sets the ListMemberStruct field's value.
func (s *OutputService4TestShapeOutputShape) SetListMemberStruct(v []*OutputService4TestShapeStructType) *OutputService4TestShapeOutputShape {
func (s *OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberStruct(v []*OutputService4TestShapeStructType) *OutputService4TestShapeOutputService4TestCaseOperation2Output {
s.ListMemberStruct = v
return s
}
@@ -796,8 +807,12 @@ type OutputService4TestShapeStructType struct {
_ struct{} `type:"structure"`
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService5ProtocolTest struct {
*client.Client
}
@@ -855,19 +870,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService5TestCaseOperation1 method directly
// instead.
// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService5TestCaseOperation1Request method.
// req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -936,8 +950,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetMapMe
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService6ProtocolTest struct {
*client.Client
}
@@ -995,19 +1013,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService6TestCaseOperation1 method directly
// instead.
// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService6TestCaseOperation1Request method.
// req, resp := client.OutputService6TestCaseOperation1Request(params)
vendor/github.com/aws/aws-sdk-go/private/protocol/protocol_test.go
Generated Vendored
+4 -4
View File
@@ -1,7 +1,6 @@
package protocol_test
import (
"fmt"
"net/http"
"net/url"
"testing"
@@ -21,11 +20,13 @@ import (
)
func xmlData(set bool, b []byte, size, delta int) {
const openingTags = "<B><A>"
const closingTags = "</A></B>"
if !set {
copy(b, []byte("<B><A>"))
copy(b, []byte(openingTags))
}
if size == 0 {
copy(b[delta-len("</B></A>"):], []byte("</B></A>"))
copy(b[delta-len(closingTags):], []byte(closingTags))
}
}
@@ -118,7 +119,6 @@ func checkForLeak(data interface{}, build, fn func(*request.Request), t *testing
if result.errExists {
assert.NotNil(t, req.Error)
} else {
fmt.Println(req.Error)
assert.Nil(t, req.Error)
}
vendor/github.com/aws/aws-sdk-go/private/protocol/query/build_test.go
Generated Vendored
+394 -365
View File
File diff suppressed because it is too large Load Diff
vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_test.go
Generated Vendored
+225 -180
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation1 method directly
// instead.
// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation1Request method.
// req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -249,8 +252,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService2ProtocolTest struct {
*client.Client
}
@@ -308,19 +315,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService2TestCaseOperation1 method directly
// instead.
// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService2TestCaseOperation1Request method.
// req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -397,8 +403,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStr(v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService3ProtocolTest struct {
*client.Client
}
@@ -456,19 +466,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService3TestCaseOperation1 method directly
// instead.
// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService3TestCaseOperation1Request method.
// req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -538,8 +547,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetBlob(
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService4ProtocolTest struct {
*client.Client
}
@@ -597,19 +610,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation1 method directly
// instead.
// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation1Request method.
// req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -678,8 +690,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService5ProtocolTest struct {
*client.Client
}
@@ -737,19 +753,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService5TestCaseOperation1 method directly
// instead.
// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService5TestCaseOperation1Request method.
// req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -818,8 +833,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService6ProtocolTest struct {
*client.Client
}
@@ -877,19 +896,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService6TestCaseOperation1 method directly
// instead.
// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService6TestCaseOperation1Request method.
// req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -958,8 +976,12 @@ func (s *OutputService6TestShapeOutputService6TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService7ProtocolTest struct {
*client.Client
}
@@ -1017,19 +1039,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
// OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService7TestCaseOperation1 method directly
// instead.
// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService7TestCaseOperation1Request method.
// req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1098,8 +1119,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService8ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService8ProtocolTest struct {
*client.Client
}
@@ -1157,19 +1182,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
// OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService8TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService8TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService8TestCaseOperation1 method directly
// instead.
// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService8TestCaseOperation1Request method.
// req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1266,8 +1290,12 @@ func (s *OutputService8TestShapeStructureShape) SetFoo(v string) *OutputService8
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService9ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService9ProtocolTest struct {
*client.Client
}
@@ -1325,19 +1353,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
// OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService9TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService9TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService9TestCaseOperation1 method directly
// instead.
// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService9TestCaseOperation1Request method.
// req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1434,8 +1461,12 @@ func (s *OutputService9TestShapeStructureShape) SetFoo(v string) *OutputService9
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService10ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService10ProtocolTest struct {
*client.Client
}
@@ -1493,19 +1524,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
// OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService10TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService10TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService10TestCaseOperation1 method directly
// instead.
// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService10TestCaseOperation1Request method.
// req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1574,8 +1604,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetLis
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService11ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService11ProtocolTest struct {
*client.Client
}
@@ -1633,19 +1667,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
// OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService11TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService11TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService11TestCaseOperation1 method directly
// instead.
// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService11TestCaseOperation1Request method.
// req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1726,8 +1759,12 @@ func (s *OutputService11TestShapeStructType) SetFoo(v string) *OutputService11Te
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService12ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService12ProtocolTest struct {
*client.Client
}
@@ -1785,19 +1822,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
// OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService12TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService12TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService12TestCaseOperation1 method directly
// instead.
// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService12TestCaseOperation1Request method.
// req, resp := client.OutputService12TestCaseOperation1Request(params)
@@ -1866,8 +1902,12 @@ func (s *OutputService12TestShapeOutputService12TestCaseOperation1Output) SetMap
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService13ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService13ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService13ProtocolTest struct {
*client.Client
}
@@ -1925,19 +1965,18 @@ const opOutputService13TestCaseOperation1 = "OperationName"
// OutputService13TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService13TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService13TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService13TestCaseOperation1 method directly
// instead.
// See OutputService13TestCaseOperation1 for more information on using the OutputService13TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService13TestCaseOperation1Request method.
// req, resp := client.OutputService13TestCaseOperation1Request(params)
@@ -2006,8 +2045,12 @@ func (s *OutputService13TestShapeOutputService13TestCaseOperation1Output) SetMap
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService14ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService14ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService14ProtocolTest struct {
*client.Client
}
@@ -2065,19 +2108,18 @@ const opOutputService14TestCaseOperation1 = "OperationName"
// OutputService14TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService14TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService14TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService14TestCaseOperation1 method directly
// instead.
// See OutputService14TestCaseOperation1 for more information on using the OutputService14TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService14TestCaseOperation1Request method.
// req, resp := client.OutputService14TestCaseOperation1Request(params)
@@ -2146,8 +2188,12 @@ func (s *OutputService14TestShapeOutputService14TestCaseOperation1Output) SetMap
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService15ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService15ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService15ProtocolTest struct {
*client.Client
}
@@ -2205,19 +2251,18 @@ const opOutputService15TestCaseOperation1 = "OperationName"
// OutputService15TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService15TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService15TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService15TestCaseOperation1 method directly
// instead.
// See OutputService15TestCaseOperation1 for more information on using the OutputService15TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService15TestCaseOperation1Request method.
// req, resp := client.OutputService15TestCaseOperation1Request(params)
vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_bench_test.go
Generated Vendored
+223 -229
View File
@@ -3,232 +3,131 @@
package restjson_test
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/endpoints"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/awstesting"
"github.com/aws/aws-sdk-go/private/protocol/rest"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/private/protocol/restjson"
"github.com/aws/aws-sdk-go/service/elastictranscoder"
)
func BenchmarkRESTJSONBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
svc := awstesting.NewClient()
svc.ServiceName = "elastictranscoder"
svc.APIVersion = "2012-09-25"
var (
elastictranscoderSvc *elastictranscoder.ElasticTranscoder
)
func TestMain(m *testing.M) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
sess := session.Must(session.NewSession(&aws.Config{
Credentials: credentials.NewStaticCredentials("Key", "Secret", "Token"),
Endpoint: aws.String(server.URL),
S3ForcePathStyle: aws.Bool(true),
DisableSSL: aws.Bool(true),
Region: aws.String(endpoints.UsWest2RegionID),
}))
elastictranscoderSvc = elastictranscoder.New(sess)
c := m.Run()
server.Close()
os.Exit(c)
}
func BenchmarkRESTJSONBuild_Complex_ETCCreateJob(b *testing.B) {
params := elastictranscoderCreateJobInput()
benchRESTJSONBuild(b, func() *request.Request {
req, _ := elastictranscoderSvc.CreateJobRequest(params)
return req
})
}
func BenchmarkRESTJSONBuild_Simple_ETCListJobsByPipeline(b *testing.B) {
params := elastictranscoderListJobsByPipeline()
benchRESTJSONBuild(b, func() *request.Request {
req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(params)
return req
})
}
func BenchmarkRESTJSONRequest_Complex_CFCreateJob(b *testing.B) {
benchRESTJSONRequest(b, func() *request.Request {
req, _ := elastictranscoderSvc.CreateJobRequest(elastictranscoderCreateJobInput())
return req
})
}
func BenchmarkRESTJSONRequest_Simple_ETCListJobsByPipeline(b *testing.B) {
benchRESTJSONRequest(b, func() *request.Request {
req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(elastictranscoderListJobsByPipeline())
return req
})
}
func benchRESTJSONBuild(b *testing.B, reqFn func() *request.Request) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
restjson.Build(r)
if r.Error != nil {
b.Fatal("Unexpected error", r.Error)
req := reqFn()
restjson.Build(req)
if req.Error != nil {
b.Fatal("Unexpected error", req.Error)
}
}
}
func BenchmarkRESTBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
svc := awstesting.NewClient()
svc.ServiceName = "elastictranscoder"
svc.APIVersion = "2012-09-25"
func benchRESTJSONRequest(b *testing.B, reqFn func() *request.Request) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
rest.Build(r)
if r.Error != nil {
b.Fatal("Unexpected error", r.Error)
}
}
}
func BenchmarkEncodingJSONMarshal_Complex_elastictranscoderCreateJobInput(b *testing.B) {
params := restjsonBuildParms
for i := 0; i < b.N; i++ {
buf := &bytes.Buffer{}
encoder := json.NewEncoder(buf)
if err := encoder.Encode(params); err != nil {
err := reqFn().Send()
if err != nil {
b.Fatal("Unexpected error", err)
}
}
}
func BenchmarkRESTJSONBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
svc := awstesting.NewClient()
svc.ServiceName = "elastictranscoder"
svc.APIVersion = "2012-09-25"
params := &elastictranscoder.ListJobsByPipelineInput{
func elastictranscoderListJobsByPipeline() *elastictranscoder.ListJobsByPipelineInput {
return &elastictranscoder.ListJobsByPipelineInput{
PipelineId: aws.String("Id"), // Required
Ascending: aws.String("Ascending"),
PageToken: aws.String("Id"),
}
for i := 0; i < b.N; i++ {
r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
restjson.Build(r)
if r.Error != nil {
b.Fatal("Unexpected error", r.Error)
}
}
}
func BenchmarkRESTBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
svc := awstesting.NewClient()
svc.ServiceName = "elastictranscoder"
svc.APIVersion = "2012-09-25"
params := &elastictranscoder.ListJobsByPipelineInput{
func elastictranscoderCreateJobInput() *elastictranscoder.CreateJobInput {
return &elastictranscoder.CreateJobInput{
Input: &elastictranscoder.JobInput{ // Required
AspectRatio: aws.String("AspectRatio"),
Container: aws.String("JobContainer"),
DetectedProperties: &elastictranscoder.DetectedProperties{
DurationMillis: aws.Int64(1),
FileSize: aws.Int64(1),
FrameRate: aws.String("FloatString"),
Height: aws.Int64(1),
Width: aws.Int64(1),
},
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
FrameRate: aws.String("FrameRate"),
Interlaced: aws.String("Interlaced"),
Key: aws.String("Key"),
Resolution: aws.String("Resolution"),
},
PipelineId: aws.String("Id"), // Required
Ascending: aws.String("Ascending"),
PageToken: aws.String("Id"),
}
for i := 0; i < b.N; i++ {
r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
rest.Build(r)
if r.Error != nil {
b.Fatal("Unexpected error", r.Error)
}
}
}
func BenchmarkEncodingJSONMarshal_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
params := &elastictranscoder.ListJobsByPipelineInput{
PipelineId: aws.String("Id"), // Required
Ascending: aws.String("Ascending"),
PageToken: aws.String("Id"),
}
for i := 0; i < b.N; i++ {
buf := &bytes.Buffer{}
encoder := json.NewEncoder(buf)
if err := encoder.Encode(params); err != nil {
b.Fatal("Unexpected error", err)
}
}
}
var restjsonBuildParms = &elastictranscoder.CreateJobInput{
Input: &elastictranscoder.JobInput{ // Required
AspectRatio: aws.String("AspectRatio"),
Container: aws.String("JobContainer"),
DetectedProperties: &elastictranscoder.DetectedProperties{
DurationMillis: aws.Int64(1),
FileSize: aws.Int64(1),
FrameRate: aws.String("FloatString"),
Height: aws.Int64(1),
Width: aws.Int64(1),
},
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
FrameRate: aws.String("FrameRate"),
Interlaced: aws.String("Interlaced"),
Key: aws.String("Key"),
Resolution: aws.String("Resolution"),
},
PipelineId: aws.String("Id"), // Required
Output: &elastictranscoder.CreateJobOutput{
AlbumArt: &elastictranscoder.JobAlbumArt{
Artwork: []*elastictranscoder.Artwork{
{ // Required
AlbumArtFormat: aws.String("JpgOrPng"),
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
InputKey: aws.String("WatermarkKey"),
MaxHeight: aws.String("DigitsOrAuto"),
MaxWidth: aws.String("DigitsOrAuto"),
PaddingPolicy: aws.String("PaddingPolicy"),
SizingPolicy: aws.String("SizingPolicy"),
},
// More values...
},
MergePolicy: aws.String("MergePolicy"),
},
Captions: &elastictranscoder.Captions{
CaptionFormats: []*elastictranscoder.CaptionFormat{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Format: aws.String("CaptionFormatFormat"),
Pattern: aws.String("CaptionFormatPattern"),
},
// More values...
},
CaptionSources: []*elastictranscoder.CaptionSource{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Key: aws.String("Key"),
Label: aws.String("Name"),
Language: aws.String("Key"),
TimeOffset: aws.String("TimeOffset"),
},
// More values...
},
MergePolicy: aws.String("CaptionMergePolicy"),
},
Composition: []*elastictranscoder.Clip{
{ // Required
TimeSpan: &elastictranscoder.TimeSpan{
Duration: aws.String("Time"),
StartTime: aws.String("Time"),
},
},
// More values...
},
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Key: aws.String("Key"),
PresetId: aws.String("Id"),
Rotate: aws.String("Rotate"),
SegmentDuration: aws.String("FloatString"),
ThumbnailEncryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
ThumbnailPattern: aws.String("ThumbnailPattern"),
Watermarks: []*elastictranscoder.JobWatermark{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
InputKey: aws.String("WatermarkKey"),
PresetWatermarkId: aws.String("PresetWatermarkId"),
},
// More values...
},
},
OutputKeyPrefix: aws.String("Key"),
Outputs: []*elastictranscoder.CreateJobOutput{
{ // Required
Output: &elastictranscoder.CreateJobOutput{
AlbumArt: &elastictranscoder.JobAlbumArt{
Artwork: []*elastictranscoder.Artwork{
{ // Required
@@ -320,37 +219,132 @@ var restjsonBuildParms = &elastictranscoder.CreateJobInput{
// More values...
},
},
// More values...
},
Playlists: []*elastictranscoder.CreateJobPlaylist{
{ // Required
Format: aws.String("PlaylistFormat"),
HlsContentProtection: &elastictranscoder.HlsContentProtection{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
KeyStoragePolicy: aws.String("KeyStoragePolicy"),
LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
Method: aws.String("HlsContentProtectionMethod"),
},
Name: aws.String("Filename"),
OutputKeys: []*string{
aws.String("Key"), // Required
// More values...
},
PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
Format: aws.String("PlayReadyDrmFormatString"),
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("NonEmptyBase64EncodedString"),
KeyId: aws.String("KeyIdGuid"),
KeyMd5: aws.String("NonEmptyBase64EncodedString"),
LicenseAcquisitionUrl: aws.String("OneTo512String"),
OutputKeyPrefix: aws.String("Key"),
Outputs: []*elastictranscoder.CreateJobOutput{
{ // Required
AlbumArt: &elastictranscoder.JobAlbumArt{
Artwork: []*elastictranscoder.Artwork{
{ // Required
AlbumArtFormat: aws.String("JpgOrPng"),
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
InputKey: aws.String("WatermarkKey"),
MaxHeight: aws.String("DigitsOrAuto"),
MaxWidth: aws.String("DigitsOrAuto"),
PaddingPolicy: aws.String("PaddingPolicy"),
SizingPolicy: aws.String("SizingPolicy"),
},
// More values...
},
MergePolicy: aws.String("MergePolicy"),
},
Captions: &elastictranscoder.Captions{
CaptionFormats: []*elastictranscoder.CaptionFormat{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Format: aws.String("CaptionFormatFormat"),
Pattern: aws.String("CaptionFormatPattern"),
},
// More values...
},
CaptionSources: []*elastictranscoder.CaptionSource{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Key: aws.String("Key"),
Label: aws.String("Name"),
Language: aws.String("Key"),
TimeOffset: aws.String("TimeOffset"),
},
// More values...
},
MergePolicy: aws.String("CaptionMergePolicy"),
},
Composition: []*elastictranscoder.Clip{
{ // Required
TimeSpan: &elastictranscoder.TimeSpan{
Duration: aws.String("Time"),
StartTime: aws.String("Time"),
},
},
// More values...
},
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
Key: aws.String("Key"),
PresetId: aws.String("Id"),
Rotate: aws.String("Rotate"),
SegmentDuration: aws.String("FloatString"),
ThumbnailEncryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
ThumbnailPattern: aws.String("ThumbnailPattern"),
Watermarks: []*elastictranscoder.JobWatermark{
{ // Required
Encryption: &elastictranscoder.Encryption{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
Mode: aws.String("EncryptionMode"),
},
InputKey: aws.String("WatermarkKey"),
PresetWatermarkId: aws.String("PresetWatermarkId"),
},
// More values...
},
},
// More values...
},
// More values...
},
UserMetadata: map[string]*string{
"Key": aws.String("String"), // Required
// More values...
},
Playlists: []*elastictranscoder.CreateJobPlaylist{
{ // Required
Format: aws.String("PlaylistFormat"),
HlsContentProtection: &elastictranscoder.HlsContentProtection{
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("Base64EncodedString"),
KeyMd5: aws.String("Base64EncodedString"),
KeyStoragePolicy: aws.String("KeyStoragePolicy"),
LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
Method: aws.String("HlsContentProtectionMethod"),
},
Name: aws.String("Filename"),
OutputKeys: []*string{
aws.String("Key"), // Required
// More values...
},
PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
Format: aws.String("PlayReadyDrmFormatString"),
InitializationVector: aws.String("ZeroTo255String"),
Key: aws.String("NonEmptyBase64EncodedString"),
KeyId: aws.String("KeyIdGuid"),
KeyMd5: aws.String("NonEmptyBase64EncodedString"),
LicenseAcquisitionUrl: aws.String("OneTo512String"),
},
},
// More values...
},
UserMetadata: map[string]*string{
"Key": aws.String("String"), // Required
// More values...
},
}
}
vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_test.go
Generated Vendored
+572 -521
View File
File diff suppressed because it is too large Load Diff
vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/unmarshal_test.go
Generated Vendored
+180 -144
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation1 method directly
// instead.
// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation1Request method.
// req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -265,8 +268,12 @@ func (s *OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueB
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService2ProtocolTest struct {
*client.Client
}
@@ -324,19 +331,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService2TestCaseOperation1 method directly
// instead.
// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService2TestCaseOperation1Request method.
// req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -427,8 +433,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStruc
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService3ProtocolTest struct {
*client.Client
}
@@ -486,19 +496,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService3TestCaseOperation1 method directly
// instead.
// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService3TestCaseOperation1Request method.
// req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -587,8 +596,12 @@ func (s *OutputService3TestShapeTimeContainer) SetFoo(v time.Time) *OutputServic
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService4ProtocolTest struct {
*client.Client
}
@@ -646,19 +659,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation1 method directly
// instead.
// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation1Request method.
// req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -727,8 +739,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService5ProtocolTest struct {
*client.Client
}
@@ -786,19 +802,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService5TestCaseOperation1 method directly
// instead.
// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService5TestCaseOperation1Request method.
// req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -879,8 +894,12 @@ func (s *OutputService5TestShapeSingleStruct) SetFoo(v string) *OutputService5Te
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService6ProtocolTest struct {
*client.Client
}
@@ -938,19 +957,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService6TestCaseOperation1 method directly
// instead.
// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService6TestCaseOperation1Request method.
// req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -1019,8 +1037,12 @@ func (s *OutputService6TestShapeOutputService6TestCaseOperation1Output) SetMapMe
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService7ProtocolTest struct {
*client.Client
}
@@ -1078,19 +1100,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
// OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService7TestCaseOperation1 method directly
// instead.
// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService7TestCaseOperation1Request method.
// req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1159,8 +1180,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMapMe
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService8ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService8ProtocolTest struct {
*client.Client
}
@@ -1218,19 +1243,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
// OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService8TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService8TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService8TestCaseOperation1 method directly
// instead.
// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService8TestCaseOperation1Request method.
// req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1299,8 +1323,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetStrTy
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService9ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService9ProtocolTest struct {
*client.Client
}
@@ -1358,19 +1386,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
// OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService9TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService9TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService9TestCaseOperation1 method directly
// instead.
// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService9TestCaseOperation1Request method.
// req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1447,8 +1474,12 @@ func (s *OutputService9TestShapeOutputService9TestCaseOperation1Output) SetPrefi
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService10ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService10ProtocolTest struct {
*client.Client
}
@@ -1506,19 +1537,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
// OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService10TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService10TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService10TestCaseOperation1 method directly
// instead.
// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService10TestCaseOperation1Request method.
// req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1607,8 +1637,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetHea
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService11ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService11ProtocolTest struct {
*client.Client
}
@@ -1666,19 +1700,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
// OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService11TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService11TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService11TestCaseOperation1 method directly
// instead.
// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService11TestCaseOperation1Request method.
// req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1747,8 +1780,12 @@ func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetStr
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService12ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService12ProtocolTest struct {
*client.Client
}
@@ -1806,19 +1843,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
// OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService12TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService12TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService12TestCaseOperation1 method directly
// instead.
// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService12TestCaseOperation1Request method.
// req, resp := client.OutputService12TestCaseOperation1Request(params)
vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_bench_test.go
Generated Vendored
+301 -181
View File
@@ -3,47 +3,115 @@
package restxml_test
import (
"net/http"
"net/http/httptest"
"os"
"testing"
"bytes"
"encoding/xml"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/endpoints"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/awstesting"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/private/protocol/restxml"
"github.com/aws/aws-sdk-go/service/cloudfront"
"github.com/aws/aws-sdk-go/service/s3"
)
func BenchmarkRESTXMLBuild_Complex_cloudfrontCreateDistribution(b *testing.B) {
params := restxmlBuildCreateDistroParms
var (
cloudfrontSvc *cloudfront.CloudFront
s3Svc *s3.S3
)
op := &request.Operation{
Name: "CreateDistribution",
HTTPMethod: "POST",
HTTPPath: "/2015-04-17/distribution/{DistributionId}/invalidation",
}
func TestMain(m *testing.M) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
benchRESTXMLBuild(b, op, params)
sess := session.Must(session.NewSession(&aws.Config{
Credentials: credentials.NewStaticCredentials("Key", "Secret", "Token"),
Endpoint: aws.String(server.URL),
S3ForcePathStyle: aws.Bool(true),
DisableSSL: aws.Bool(true),
Region: aws.String(endpoints.UsWest2RegionID),
}))
cloudfrontSvc = cloudfront.New(sess)
s3Svc = s3.New(sess)
c := m.Run()
server.Close()
os.Exit(c)
}
func BenchmarkRESTXMLBuild_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
params := &cloudfront.DeleteDistributionInput{
Id: aws.String("string"), // Required
IfMatch: aws.String("string"),
}
op := &request.Operation{
Name: "DeleteStreamingDistribution",
HTTPMethod: "DELETE",
HTTPPath: "/2015-04-17/streaming-distribution/{Id}",
}
benchRESTXMLBuild(b, op, params)
func BenchmarkRESTXMLBuild_Complex_CFCreateDistro(b *testing.B) {
params := cloudfrontCreateDistributionInput()
benchRESTXMLBuild(b, func() *request.Request {
req, _ := cloudfrontSvc.CreateDistributionRequest(params)
return req
})
}
func BenchmarkEncodingXMLMarshal_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
params := &cloudfront.DeleteDistributionInput{
Id: aws.String("string"), // Required
IfMatch: aws.String("string"),
}
func BenchmarkRESTXMLBuild_Simple_CFDeleteDistro(b *testing.B) {
params := cloudfrontDeleteDistributionInput()
benchRESTXMLBuild(b, func() *request.Request {
req, _ := cloudfrontSvc.DeleteDistributionRequest(params)
return req
})
}
func BenchmarkRESTXMLBuild_REST_S3HeadObject(b *testing.B) {
params := s3HeadObjectInput()
benchRESTXMLBuild(b, func() *request.Request {
req, _ := s3Svc.HeadObjectRequest(params)
return req
})
}
func BenchmarkRESTXMLBuild_XML_S3PutObjectAcl(b *testing.B) {
params := s3PutObjectAclInput()
benchRESTXMLBuild(b, func() *request.Request {
req, _ := s3Svc.PutObjectAclRequest(params)
return req
})
}
func BenchmarkRESTXMLRequest_Complex_CFCreateDistro(b *testing.B) {
benchRESTXMLRequest(b, func() *request.Request {
req, _ := cloudfrontSvc.CreateDistributionRequest(cloudfrontCreateDistributionInput())
return req
})
}
func BenchmarkRESTXMLRequest_Simple_CFDeleteDistro(b *testing.B) {
benchRESTXMLRequest(b, func() *request.Request {
req, _ := cloudfrontSvc.DeleteDistributionRequest(cloudfrontDeleteDistributionInput())
return req
})
}
func BenchmarkRESTXMLRequest_REST_S3HeadObject(b *testing.B) {
benchRESTXMLRequest(b, func() *request.Request {
req, _ := s3Svc.HeadObjectRequest(s3HeadObjectInput())
return req
})
}
func BenchmarkRESTXMLRequest_XML_S3PutObjectAcl(b *testing.B) {
benchRESTXMLRequest(b, func() *request.Request {
req, _ := s3Svc.PutObjectAclRequest(s3PutObjectAclInput())
return req
})
}
func BenchmarkEncodingXML_Simple(b *testing.B) {
params := cloudfrontDeleteDistributionInput()
for i := 0; i < b.N; i++ {
buf := &bytes.Buffer{}
@@ -54,118 +122,39 @@ func BenchmarkEncodingXMLMarshal_Simple_cloudfrontDeleteStreamingDistribution(b
}
}
func benchRESTXMLBuild(b *testing.B, op *request.Operation, params interface{}) {
svc := awstesting.NewClient()
svc.ServiceName = "cloudfront"
svc.APIVersion = "2015-04-17"
func benchRESTXMLBuild(b *testing.B, reqFn func() *request.Request) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r := svc.NewRequest(op, params, nil)
restxml.Build(r)
if r.Error != nil {
b.Fatal("Unexpected error", r.Error)
req := reqFn()
restxml.Build(req)
if req.Error != nil {
b.Fatal("Unexpected error", req.Error)
}
}
}
var restxmlBuildCreateDistroParms = &cloudfront.CreateDistributionInput{
DistributionConfig: &cloudfront.DistributionConfig{ // Required
CallerReference: aws.String("string"), // Required
Comment: aws.String("string"), // Required
DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
ForwardedValues: &cloudfront.ForwardedValues{ // Required
Cookies: &cloudfront.CookiePreference{ // Required
Forward: aws.String("ItemSelection"), // Required
WhitelistedNames: &cloudfront.CookieNames{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
QueryString: aws.Bool(true), // Required
Headers: &cloudfront.Headers{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
MinTTL: aws.Int64(1), // Required
TargetOriginId: aws.String("string"), // Required
TrustedSigners: &cloudfront.TrustedSigners{ // Required
Enabled: aws.Bool(true), // Required
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
AllowedMethods: &cloudfront.AllowedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
CachedMethods: &cloudfront.CachedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
},
},
DefaultTTL: aws.Int64(1),
MaxTTL: aws.Int64(1),
SmoothStreaming: aws.Bool(true),
},
Enabled: aws.Bool(true), // Required
Origins: &cloudfront.Origins{ // Required
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.Origin{
{ // Required
DomainName: aws.String("string"), // Required
Id: aws.String("string"), // Required
CustomOriginConfig: &cloudfront.CustomOriginConfig{
HTTPPort: aws.Int64(1), // Required
HTTPSPort: aws.Int64(1), // Required
OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
},
OriginPath: aws.String("string"),
S3OriginConfig: &cloudfront.S3OriginConfig{
OriginAccessIdentity: aws.String("string"), // Required
},
},
// More values...
},
},
Aliases: &cloudfront.Aliases{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
CacheBehaviors: &cloudfront.CacheBehaviors{
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.CacheBehavior{
{ // Required
ForwardedValues: &cloudfront.ForwardedValues{ // Required
Cookies: &cloudfront.CookiePreference{ // Required
Forward: aws.String("ItemSelection"), // Required
WhitelistedNames: &cloudfront.CookieNames{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
QueryString: aws.Bool(true), // Required
Headers: &cloudfront.Headers{
func benchRESTXMLRequest(b *testing.B, reqFn func() *request.Request) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
err := reqFn().Send()
if err != nil {
b.Fatal("Unexpected error", err)
}
}
}
func cloudfrontCreateDistributionInput() *cloudfront.CreateDistributionInput {
return &cloudfront.CreateDistributionInput{
DistributionConfig: &cloudfront.DistributionConfig{ // Required
CallerReference: aws.String("string"), // Required
Comment: aws.String("string"), // Required
DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
ForwardedValues: &cloudfront.ForwardedValues{ // Required
Cookies: &cloudfront.CookiePreference{ // Required
Forward: aws.String("ItemSelection"), // Required
WhitelistedNames: &cloudfront.CookieNames{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
@@ -173,74 +162,205 @@ var restxmlBuildCreateDistroParms = &cloudfront.CreateDistributionInput{
},
},
},
MinTTL: aws.Int64(1), // Required
PathPattern: aws.String("string"), // Required
TargetOriginId: aws.String("string"), // Required
TrustedSigners: &cloudfront.TrustedSigners{ // Required
Enabled: aws.Bool(true), // Required
Quantity: aws.Int64(1), // Required
QueryString: aws.Bool(true), // Required
Headers: &cloudfront.Headers{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
AllowedMethods: &cloudfront.AllowedMethods{
},
MinTTL: aws.Int64(1), // Required
TargetOriginId: aws.String("string"), // Required
TrustedSigners: &cloudfront.TrustedSigners{ // Required
Enabled: aws.Bool(true), // Required
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
AllowedMethods: &cloudfront.AllowedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
CachedMethods: &cloudfront.CachedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
CachedMethods: &cloudfront.CachedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
},
},
DefaultTTL: aws.Int64(1),
MaxTTL: aws.Int64(1),
SmoothStreaming: aws.Bool(true),
},
Enabled: aws.Bool(true), // Required
Origins: &cloudfront.Origins{ // Required
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.Origin{
{ // Required
DomainName: aws.String("string"), // Required
Id: aws.String("string"), // Required
CustomOriginConfig: &cloudfront.CustomOriginConfig{
HTTPPort: aws.Int64(1), // Required
HTTPSPort: aws.Int64(1), // Required
OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
},
OriginPath: aws.String("string"),
S3OriginConfig: &cloudfront.S3OriginConfig{
OriginAccessIdentity: aws.String("string"), // Required
},
},
DefaultTTL: aws.Int64(1),
MaxTTL: aws.Int64(1),
SmoothStreaming: aws.Bool(true),
// More values...
},
// More values...
},
},
CustomErrorResponses: &cloudfront.CustomErrorResponses{
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.CustomErrorResponse{
{ // Required
ErrorCode: aws.Int64(1), // Required
ErrorCachingMinTTL: aws.Int64(1),
ResponseCode: aws.String("string"),
ResponsePagePath: aws.String("string"),
},
// More values...
},
},
DefaultRootObject: aws.String("string"),
Logging: &cloudfront.LoggingConfig{
Bucket: aws.String("string"), // Required
Enabled: aws.Bool(true), // Required
IncludeCookies: aws.Bool(true), // Required
Prefix: aws.String("string"), // Required
},
PriceClass: aws.String("PriceClass"),
Restrictions: &cloudfront.Restrictions{
GeoRestriction: &cloudfront.GeoRestriction{ // Required
Quantity: aws.Int64(1), // Required
RestrictionType: aws.String("GeoRestrictionType"), // Required
Aliases: &cloudfront.Aliases{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
CacheBehaviors: &cloudfront.CacheBehaviors{
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.CacheBehavior{
{ // Required
ForwardedValues: &cloudfront.ForwardedValues{ // Required
Cookies: &cloudfront.CookiePreference{ // Required
Forward: aws.String("ItemSelection"), // Required
WhitelistedNames: &cloudfront.CookieNames{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
QueryString: aws.Bool(true), // Required
Headers: &cloudfront.Headers{
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
MinTTL: aws.Int64(1), // Required
PathPattern: aws.String("string"), // Required
TargetOriginId: aws.String("string"), // Required
TrustedSigners: &cloudfront.TrustedSigners{ // Required
Enabled: aws.Bool(true), // Required
Quantity: aws.Int64(1), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
AllowedMethods: &cloudfront.AllowedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
CachedMethods: &cloudfront.CachedMethods{
Items: []*string{ // Required
aws.String("Method"), // Required
// More values...
},
Quantity: aws.Int64(1), // Required
},
},
DefaultTTL: aws.Int64(1),
MaxTTL: aws.Int64(1),
SmoothStreaming: aws.Bool(true),
},
// More values...
},
},
CustomErrorResponses: &cloudfront.CustomErrorResponses{
Quantity: aws.Int64(1), // Required
Items: []*cloudfront.CustomErrorResponse{
{ // Required
ErrorCode: aws.Int64(1), // Required
ErrorCachingMinTTL: aws.Int64(1),
ResponseCode: aws.String("string"),
ResponsePagePath: aws.String("string"),
},
// More values...
},
},
DefaultRootObject: aws.String("string"),
Logging: &cloudfront.LoggingConfig{
Bucket: aws.String("string"), // Required
Enabled: aws.Bool(true), // Required
IncludeCookies: aws.Bool(true), // Required
Prefix: aws.String("string"), // Required
},
PriceClass: aws.String("PriceClass"),
Restrictions: &cloudfront.Restrictions{
GeoRestriction: &cloudfront.GeoRestriction{ // Required
Quantity: aws.Int64(1), // Required
RestrictionType: aws.String("GeoRestrictionType"), // Required
Items: []*string{
aws.String("string"), // Required
// More values...
},
},
},
ViewerCertificate: &cloudfront.ViewerCertificate{
CloudFrontDefaultCertificate: aws.Bool(true),
IAMCertificateId: aws.String("string"),
MinimumProtocolVersion: aws.String("MinimumProtocolVersion"),
SSLSupportMethod: aws.String("SSLSupportMethod"),
},
},
ViewerCertificate: &cloudfront.ViewerCertificate{
CloudFrontDefaultCertificate: aws.Bool(true),
IAMCertificateId: aws.String("string"),
MinimumProtocolVersion: aws.String("MinimumProtocolVersion"),
SSLSupportMethod: aws.String("SSLSupportMethod"),
},
},
}
}
func cloudfrontDeleteDistributionInput() *cloudfront.DeleteDistributionInput {
return &cloudfront.DeleteDistributionInput{
Id: aws.String("string"), // Required
IfMatch: aws.String("string"),
}
}
func s3HeadObjectInput() *s3.HeadObjectInput {
return &s3.HeadObjectInput{
Bucket: aws.String("somebucketname"),
Key: aws.String("keyname"),
VersionId: aws.String("someVersion"),
IfMatch: aws.String("IfMatch"),
}
}
func s3PutObjectAclInput() *s3.PutObjectAclInput {
return &s3.PutObjectAclInput{
Bucket: aws.String("somebucketname"),
Key: aws.String("keyname"),
AccessControlPolicy: &s3.AccessControlPolicy{
Grants: []*s3.Grant{
{
Grantee: &s3.Grantee{
DisplayName: aws.String("someName"),
EmailAddress: aws.String("someAddr"),
ID: aws.String("someID"),
Type: aws.String(s3.TypeCanonicalUser),
URI: aws.String("someURI"),
},
Permission: aws.String(s3.PermissionWrite),
},
},
Owner: &s3.Owner{
DisplayName: aws.String("howdy"),
ID: aws.String("someID"),
},
},
}
}
vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_test.go
Generated Vendored
+683 -626
View File
File diff suppressed because it is too large Load Diff
vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/unmarshal_test.go
Generated Vendored
+209 -174
View File
@@ -45,8 +45,12 @@ func init() {
protocol.RandReader = &awstesting.ZeroReader{}
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService1ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService1ProtocolTest struct {
*client.Client
}
@@ -104,19 +108,18 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation1 method directly
// instead.
// See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation1Request method.
// req, resp := client.OutputService1TestCaseOperation1Request(params)
@@ -125,7 +128,7 @@ const opOutputService1TestCaseOperation1 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *request.Request, output *OutputService1TestShapeOutputShape) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation2Output) {
op := &request.Operation{
Name: opOutputService1TestCaseOperation1,
HTTPPath: "/",
@@ -135,7 +138,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(inp
input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
}
output = &OutputService1TestShapeOutputShape{}
output = &OutputService1TestShapeOutputService1TestCaseOperation2Output{}
req = c.newRequest(op, input, output)
return
}
@@ -148,7 +151,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(inp
//
// See the AWS API reference guide for 's
// API operation OutputService1TestCaseOperation1 for usage and error information.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
req, out := c.OutputService1TestCaseOperation1Request(input)
return out, req.Send()
}
@@ -162,7 +165,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *Out
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation1Input, opts ...request.Option) (*OutputService1TestShapeOutputShape, error) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation1Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
req, out := c.OutputService1TestCaseOperation1Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -173,19 +176,18 @@ const opOutputService1TestCaseOperation2 = "OperationName"
// OutputService1TestCaseOperation2Request generates a "aws/request.Request" representing the
// client's request for the OutputService1TestCaseOperation2 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService1TestCaseOperation2 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService1TestCaseOperation2 method directly
// instead.
// See OutputService1TestCaseOperation2 for more information on using the OutputService1TestCaseOperation2
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService1TestCaseOperation2Request method.
// req, resp := client.OutputService1TestCaseOperation2Request(params)
@@ -194,7 +196,7 @@ const opOutputService1TestCaseOperation2 = "OperationName"
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *request.Request, output *OutputService1TestShapeOutputShape) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation2Output) {
op := &request.Operation{
Name: opOutputService1TestCaseOperation2,
HTTPPath: "/",
@@ -204,7 +206,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(inp
input = &OutputService1TestShapeOutputService1TestCaseOperation2Input{}
}
output = &OutputService1TestShapeOutputShape{}
output = &OutputService1TestShapeOutputService1TestCaseOperation2Output{}
req = c.newRequest(op, input, output)
return
}
@@ -217,7 +219,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(inp
//
// See the AWS API reference guide for 's
// API operation OutputService1TestCaseOperation2 for usage and error information.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (*OutputService1TestShapeOutputShape, error) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
req, out := c.OutputService1TestCaseOperation2Request(input)
return out, req.Send()
}
@@ -231,7 +233,7 @@ func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *Out
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (*OutputService1TestShapeOutputShape, error) {
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation2Output, error) {
req, out := c.OutputService1TestCaseOperation2Request(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
@@ -246,7 +248,7 @@ type OutputService1TestShapeOutputService1TestCaseOperation2Input struct {
_ struct{} `type:"structure"`
}
type OutputService1TestShapeOutputShape struct {
type OutputService1TestShapeOutputService1TestCaseOperation2Output struct {
_ struct{} `type:"structure"`
Char *string `type:"character"`
@@ -273,73 +275,77 @@ type OutputService1TestShapeOutputShape struct {
}
// SetChar sets the Char field's value.
func (s *OutputService1TestShapeOutputShape) SetChar(v string) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetChar(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Char = &v
return s
}
// SetDouble sets the Double field's value.
func (s *OutputService1TestShapeOutputShape) SetDouble(v float64) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetDouble(v float64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Double = &v
return s
}
// SetFalseBool sets the FalseBool field's value.
func (s *OutputService1TestShapeOutputShape) SetFalseBool(v bool) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFalseBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.FalseBool = &v
return s
}
// SetFloat sets the Float field's value.
func (s *OutputService1TestShapeOutputShape) SetFloat(v float64) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFloat(v float64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Float = &v
return s
}
// SetImaHeader sets the ImaHeader field's value.
func (s *OutputService1TestShapeOutputShape) SetImaHeader(v string) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeader(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.ImaHeader = &v
return s
}
// SetImaHeaderLocation sets the ImaHeaderLocation field's value.
func (s *OutputService1TestShapeOutputShape) SetImaHeaderLocation(v string) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeaderLocation(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.ImaHeaderLocation = &v
return s
}
// SetLong sets the Long field's value.
func (s *OutputService1TestShapeOutputShape) SetLong(v int64) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetLong(v int64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Long = &v
return s
}
// SetNum sets the Num field's value.
func (s *OutputService1TestShapeOutputShape) SetNum(v int64) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetNum(v int64) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Num = &v
return s
}
// SetStr sets the Str field's value.
func (s *OutputService1TestShapeOutputShape) SetStr(v string) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetStr(v string) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Str = &v
return s
}
// SetTimestamp sets the Timestamp field's value.
func (s *OutputService1TestShapeOutputShape) SetTimestamp(v time.Time) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTimestamp(v time.Time) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.Timestamp = &v
return s
}
// SetTrueBool sets the TrueBool field's value.
func (s *OutputService1TestShapeOutputShape) SetTrueBool(v bool) *OutputService1TestShapeOutputShape {
func (s *OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTrueBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation2Output {
s.TrueBool = &v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService2ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService2ProtocolTest struct {
*client.Client
}
@@ -397,19 +403,18 @@ const opOutputService2TestCaseOperation1 = "OperationName"
// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService2TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService2TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService2TestCaseOperation1 method directly
// instead.
// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService2TestCaseOperation1Request method.
// req, resp := client.OutputService2TestCaseOperation1Request(params)
@@ -479,8 +484,12 @@ func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService3ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService3ProtocolTest struct {
*client.Client
}
@@ -538,19 +547,18 @@ const opOutputService3TestCaseOperation1 = "OperationName"
// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService3TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService3TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService3TestCaseOperation1 method directly
// instead.
// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService3TestCaseOperation1Request method.
// req, resp := client.OutputService3TestCaseOperation1Request(params)
@@ -619,8 +627,12 @@ func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService4ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService4ProtocolTest struct {
*client.Client
}
@@ -678,19 +690,18 @@ const opOutputService4TestCaseOperation1 = "OperationName"
// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService4TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService4TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService4TestCaseOperation1 method directly
// instead.
// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService4TestCaseOperation1Request method.
// req, resp := client.OutputService4TestCaseOperation1Request(params)
@@ -759,8 +770,12 @@ func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService5ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService5ProtocolTest struct {
*client.Client
}
@@ -818,19 +833,18 @@ const opOutputService5TestCaseOperation1 = "OperationName"
// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService5TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService5TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService5TestCaseOperation1 method directly
// instead.
// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService5TestCaseOperation1Request method.
// req, resp := client.OutputService5TestCaseOperation1Request(params)
@@ -899,8 +913,12 @@ func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListM
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService6ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService6ProtocolTest struct {
*client.Client
}
@@ -958,19 +976,18 @@ const opOutputService6TestCaseOperation1 = "OperationName"
// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService6TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService6TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService6TestCaseOperation1 method directly
// instead.
// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService6TestCaseOperation1Request method.
// req, resp := client.OutputService6TestCaseOperation1Request(params)
@@ -1051,8 +1068,12 @@ func (s *OutputService6TestShapeSingleStructure) SetFoo(v string) *OutputService
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService7ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService7ProtocolTest struct {
*client.Client
}
@@ -1110,19 +1131,18 @@ const opOutputService7TestCaseOperation1 = "OperationName"
// OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService7TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService7TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService7TestCaseOperation1 method directly
// instead.
// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService7TestCaseOperation1Request method.
// req, resp := client.OutputService7TestCaseOperation1Request(params)
@@ -1191,8 +1211,12 @@ func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService8ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService8ProtocolTest struct {
*client.Client
}
@@ -1250,19 +1274,18 @@ const opOutputService8TestCaseOperation1 = "OperationName"
// OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService8TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService8TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService8TestCaseOperation1 method directly
// instead.
// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService8TestCaseOperation1Request method.
// req, resp := client.OutputService8TestCaseOperation1Request(params)
@@ -1331,8 +1354,12 @@ func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService9ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService9ProtocolTest struct {
*client.Client
}
@@ -1390,19 +1417,18 @@ const opOutputService9TestCaseOperation1 = "OperationName"
// OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService9TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService9TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService9TestCaseOperation1 method directly
// instead.
// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService9TestCaseOperation1Request method.
// req, resp := client.OutputService9TestCaseOperation1Request(params)
@@ -1491,8 +1517,12 @@ func (s *OutputService9TestShapeSingleStructure) SetFoo(v string) *OutputService
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService10ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService10ProtocolTest struct {
*client.Client
}
@@ -1550,19 +1580,18 @@ const opOutputService10TestCaseOperation1 = "OperationName"
// OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService10TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService10TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService10TestCaseOperation1 method directly
// instead.
// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService10TestCaseOperation1Request method.
// req, resp := client.OutputService10TestCaseOperation1Request(params)
@@ -1631,8 +1660,12 @@ func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetStr
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService11ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService11ProtocolTest struct {
*client.Client
}
@@ -1690,19 +1723,18 @@ const opOutputService11TestCaseOperation1 = "OperationName"
// OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService11TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService11TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService11TestCaseOperation1 method directly
// instead.
// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService11TestCaseOperation1Request method.
// req, resp := client.OutputService11TestCaseOperation1Request(params)
@@ -1835,8 +1867,12 @@ func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTru
return s
}
// The service client's operations are safe to be used concurrently.
// It is not safe to mutate any of the client's properties though.
// OutputService12ProtocolTest provides the API operation methods for making requests to
// . See this package's package overview docs
// for details on the service.
//
// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to
// modify mutate any of the struct's properties though.
type OutputService12ProtocolTest struct {
*client.Client
}
@@ -1894,19 +1930,18 @@ const opOutputService12TestCaseOperation1 = "OperationName"
// OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the
// client's request for the OutputService12TestCaseOperation1 operation. The "output" return
// value can be used to capture response data after the request's "Send" method
// is called.
// value will be populated with the request's response once the request complets
// successfuly.
//
// See OutputService12TestCaseOperation1 for usage and error information.
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// Creating a request object using this method should be used when you want to inject
// custom logic into the request's lifecycle using a custom handler, or if you want to
// access properties on the request object before or after sending the request. If
// you just want the service response, call the OutputService12TestCaseOperation1 method directly
// instead.
// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// Note: You must call the "Send" method on the returned request object in order
// to execute the request.
//
// // Example sending a request using the OutputService12TestCaseOperation1Request method.
// req, resp := client.OutputService12TestCaseOperation1Request(params)
vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go
Generated Vendored
-1
View File
@@ -131,7 +131,6 @@ func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag refl
continue
}
mTag := field.Tag
if mTag.Get("location") != "" { // skip non-body members
continue
vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
Generated Vendored
+5 -2
View File
@@ -15,7 +15,10 @@ import (
// needs to match the shape of the XML expected to be decoded.
// If the shape doesn't match unmarshaling will fail.
func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
n, _ := XMLToStruct(d, nil)
n, err := XMLToStruct(d, nil)
if err != nil {
return err
}
if n.Children != nil {
for _, root := range n.Children {
for _, c := range root {
@@ -23,7 +26,7 @@ func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
c = wrappedChild[0] // pull out wrapped element
}
err := parse(reflect.ValueOf(v), c, "")
err = parse(reflect.ValueOf(v), c, "")
if err != nil {
if err == io.EOF {
return nil
vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal_test.go
Generated Vendored
+142
View File
@@ -0,0 +1,142 @@
package xmlutil
import (
"encoding/xml"
"fmt"
"io"
"reflect"
"strings"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awsutil"
)
type mockBody struct {
DoneErr error
Body io.Reader
}
func (m *mockBody) Read(p []byte) (int, error) {
n, err := m.Body.Read(p)
if (n == 0 || err == io.EOF) && m.DoneErr != nil {
return n, m.DoneErr
}
return n, err
}
type mockOutput struct {
_ struct{} `type:"structure"`
String *string `type:"string"`
Integer *int64 `type:"integer"`
Nested *mockNestedStruct `type:"structure"`
List []*mockListElem `locationName:"List" locationNameList:"Elem" type:"list"`
Closed *mockClosedTags `type:"structure"`
}
type mockNestedStruct struct {
_ struct{} `type:"structure"`
NestedString *string `type:"string"`
NestedInt *int64 `type:"integer"`
}
type mockClosedTags struct {
_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
Attr *string `locationName:"xsi:attrval" type:"string" xmlAttribute:"true"`
}
type mockListElem struct {
_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
String *string `type:"string"`
NestedElem *mockNestedListElem `type:"structure"`
}
type mockNestedListElem struct {
_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
String *string `type:"string"`
Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"`
}
func TestUnmarshal(t *testing.T) {
const xmlBodyStr = `<?xml version="1.0" encoding="UTF-8"?>
<MockResponse xmlns="http://xmlns.example.com">
<String>string value</String>
<Integer>123</Integer>
<Closed xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:attrval="attr value"/>
<Nested>
<NestedString>nested string value</NestedString>
<NestedInt>321</NestedInt>
</Nested>
<List>
<Elem>
<NestedElem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
<String>nested elem string value</String>
</NestedElem>
<String>elem string value</String>
</Elem>
</List>
</MockResponse>`
expect := mockOutput{
String: aws.String("string value"),
Integer: aws.Int64(123),
Closed: &mockClosedTags{
Attr: aws.String("attr value"),
},
Nested: &mockNestedStruct{
NestedString: aws.String("nested string value"),
NestedInt: aws.Int64(321),
},
List: []*mockListElem{
{
String: aws.String("elem string value"),
NestedElem: &mockNestedListElem{
String: aws.String("nested elem string value"),
Type: aws.String("type"),
},
},
},
}
actual := mockOutput{}
decoder := xml.NewDecoder(strings.NewReader(xmlBodyStr))
err := UnmarshalXML(&actual, decoder, "")
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
if !reflect.DeepEqual(expect, actual) {
t.Errorf("expect unmarshal to match\nExpect: %s\nActual: %s",
awsutil.Prettify(expect), awsutil.Prettify(actual))
}
}
func TestUnmarshal_UnexpectedEOF(t *testing.T) {
const partialXMLBody = `<?xml version="1.0" encoding="UTF-8"?>
<First>first value</First>
<Second>Second val`
out := struct {
First *string `locationName:"First" type:"string"`
Second *string `locationName:"Second" type:"string"`
}{}
expect := out
expect.First = aws.String("first")
expect.Second = aws.String("second")
expectErr := fmt.Errorf("expected read error")
body := &mockBody{
DoneErr: expectErr,
Body: strings.NewReader(partialXMLBody),
}
decoder := xml.NewDecoder(body)
err := UnmarshalXML(&out, decoder, "")
if err == nil {
t.Fatalf("expect error, got none")
}
if e, a := expectErr, err; e != a {
t.Errorf("expect %v error in %v, but was not", e, a)
}
}
vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go
Generated Vendored
+9 -4
View File
@@ -40,11 +40,16 @@ func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
out := &XMLNode{}
for {
tok, err := d.Token()
if tok == nil || err == io.EOF {
break
}
if err != nil {
return out, err
if err == io.EOF {
break
} else {
return out, err
}
}
if tok == nil {
break
}
switch typed := tok.(type) {
vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct_test.go
Generated Vendored
+15 -2
View File
@@ -14,8 +14,21 @@ import (
func TestUnmarshal(t *testing.T) {
xmlVal := []byte(`<?xml version="1.0" encoding="UTF-8"?>
<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/"><Owner><ID>foo-id</ID><DisplayName>user</DisplayName></Owner><AccessControlList><Grant><Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type"><ID>foo-id</ID><DisplayName>user</DisplayName></Grantee><Permission>FULL_CONTROL</Permission></Grant></AccessControlList><
/AccessControlPolicy>`)
<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Owner>
<ID>foo-id</ID>
<DisplayName>user</DisplayName>
</Owner>
<AccessControlList>
<Grant>
<Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
<ID>foo-id</ID>
<DisplayName>user</DisplayName>
</Grantee>
<Permission>FULL_CONTROL</Permission>
</Grant>
</AccessControlList>
</AccessControlPolicy>`)
var server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write(xmlVal)