double.go

// Code generated by go doublegen; DO NOT EDIT.
// This file was generated at 2020-02-14T22:12:14+11:00

// Package datasyncdouble provides a TestDouble implementation of datasynciface.DataSyncAPI
package datasyncdouble

import (
	"context"

	"github.com/aws/aws-sdk-go/aws/awserr"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/service/datasync"
	"github.com/aws/aws-sdk-go/service/datasync/datasynciface"
	"github.com/lwoggardner/awsdouble"
	"github.com/lwoggardner/godouble/godouble"
)

// DataSyncDouble is TestDouble for datasynciface.DataSyncAPI
type DataSyncDouble struct {
	datasynciface.DataSyncAPI
	*awsdouble.AWSTestDouble
}

// Constructor for DataSyncDouble
// Default configuration will ensure
//   * API operations not explicitly stubbed will return an empty output struct pointer, and nil error.
//     To simulate long polling, "Poll" operations will return these values after a random delay of up to 100ms.
//   * WithContext methods implement a 'Fake' method that returns a cancellation error if the context is cancelled
//      before the method is called.
//   * Pages and PagesWithContext methods similarly implement a 'Fake' method that paginates over the underlying method.
//
//    This allows tests to only stub the simple api methods and be generally unconcerned whether the SUT is using the
//      Context or Pagination forms of the API.
//
func NewDouble(t godouble.T, configurators ...func(*awsdouble.AWSTestDouble)) *DataSyncDouble {
	result := &DataSyncDouble{}

	configurators = append([]func(configurator *awsdouble.AWSTestDouble){func(d *awsdouble.AWSTestDouble) {
		d.SetDefaultCall(result.defaultMethodCall)
		d.SetDefaultReturnValues(result.defaultReturnValues)
	}}, configurators...)

	result.AWSTestDouble = awsdouble.NewDouble(t, (*datasynciface.DataSyncAPI)(nil), configurators...)
	return result
}

func (d *DataSyncDouble) defaultReturnValues(m godouble.Method) godouble.ReturnValues {
	return d.DefaultReturnValues(m)
}

func (d *DataSyncDouble) defaultMethodCall(m godouble.Method) godouble.MethodCall {
	switch m.Reflect().Name {

	case "CancelTaskExecutionWithContext":
		return m.Fake(d.fakeCancelTaskExecutionWithContext)

	case "CreateAgentWithContext":
		return m.Fake(d.fakeCreateAgentWithContext)

	case "CreateLocationEfsWithContext":
		return m.Fake(d.fakeCreateLocationEfsWithContext)

	case "CreateLocationFsxWindowsWithContext":
		return m.Fake(d.fakeCreateLocationFsxWindowsWithContext)

	case "CreateLocationNfsWithContext":
		return m.Fake(d.fakeCreateLocationNfsWithContext)

	case "CreateLocationS3WithContext":
		return m.Fake(d.fakeCreateLocationS3WithContext)

	case "CreateLocationSmbWithContext":
		return m.Fake(d.fakeCreateLocationSmbWithContext)

	case "CreateTaskWithContext":
		return m.Fake(d.fakeCreateTaskWithContext)

	case "DeleteAgentWithContext":
		return m.Fake(d.fakeDeleteAgentWithContext)

	case "DeleteLocationWithContext":
		return m.Fake(d.fakeDeleteLocationWithContext)

	case "DeleteTaskWithContext":
		return m.Fake(d.fakeDeleteTaskWithContext)

	case "DescribeAgentWithContext":
		return m.Fake(d.fakeDescribeAgentWithContext)

	case "DescribeLocationEfsWithContext":
		return m.Fake(d.fakeDescribeLocationEfsWithContext)

	case "DescribeLocationFsxWindowsWithContext":
		return m.Fake(d.fakeDescribeLocationFsxWindowsWithContext)

	case "DescribeLocationNfsWithContext":
		return m.Fake(d.fakeDescribeLocationNfsWithContext)

	case "DescribeLocationS3WithContext":
		return m.Fake(d.fakeDescribeLocationS3WithContext)

	case "DescribeLocationSmbWithContext":
		return m.Fake(d.fakeDescribeLocationSmbWithContext)

	case "DescribeTaskExecutionWithContext":
		return m.Fake(d.fakeDescribeTaskExecutionWithContext)

	case "DescribeTaskWithContext":
		return m.Fake(d.fakeDescribeTaskWithContext)

	case "ListAgentsPages":
		return m.Fake(d.fakeListAgentsPages)

	case "ListAgentsPagesWithContext":
		return m.Fake(d.fakeListAgentsPagesWithContext)

	case "ListAgentsWithContext":
		return m.Fake(d.fakeListAgentsWithContext)

	case "ListLocationsPages":
		return m.Fake(d.fakeListLocationsPages)

	case "ListLocationsPagesWithContext":
		return m.Fake(d.fakeListLocationsPagesWithContext)

	case "ListLocationsWithContext":
		return m.Fake(d.fakeListLocationsWithContext)

	case "ListTagsForResourcePages":
		return m.Fake(d.fakeListTagsForResourcePages)

	case "ListTagsForResourcePagesWithContext":
		return m.Fake(d.fakeListTagsForResourcePagesWithContext)

	case "ListTagsForResourceWithContext":
		return m.Fake(d.fakeListTagsForResourceWithContext)

	case "ListTaskExecutionsPages":
		return m.Fake(d.fakeListTaskExecutionsPages)

	case "ListTaskExecutionsPagesWithContext":
		return m.Fake(d.fakeListTaskExecutionsPagesWithContext)

	case "ListTaskExecutionsWithContext":
		return m.Fake(d.fakeListTaskExecutionsWithContext)

	case "ListTasksPages":
		return m.Fake(d.fakeListTasksPages)

	case "ListTasksPagesWithContext":
		return m.Fake(d.fakeListTasksPagesWithContext)

	case "ListTasksWithContext":
		return m.Fake(d.fakeListTasksWithContext)

	case "StartTaskExecutionWithContext":
		return m.Fake(d.fakeStartTaskExecutionWithContext)

	case "TagResourceWithContext":
		return m.Fake(d.fakeTagResourceWithContext)

	case "UntagResourceWithContext":
		return m.Fake(d.fakeUntagResourceWithContext)

	case "UpdateAgentWithContext":
		return m.Fake(d.fakeUpdateAgentWithContext)

	case "UpdateTaskWithContext":
		return m.Fake(d.fakeUpdateTaskWithContext)

	default:
		return nil
	}
}

func (d *DataSyncDouble) CancelTaskExecution(i0 *datasync.CancelTaskExecutionInput) (r0 *datasync.CancelTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelTaskExecution", i0)
	r0, _ = returns[0].(*datasync.CancelTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CancelTaskExecutionRequest(i0 *datasync.CancelTaskExecutionInput) (r0 *request.Request, r1 *datasync.CancelTaskExecutionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelTaskExecutionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CancelTaskExecutionOutput)
	return
}

func (d *DataSyncDouble) CancelTaskExecutionWithContext(i0 context.Context, i1 *datasync.CancelTaskExecutionInput, i2 ...request.Option) (r0 *datasync.CancelTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelTaskExecutionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CancelTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCancelTaskExecutionWithContext(ctx context.Context, in *datasync.CancelTaskExecutionInput, _ ...request.Option) (*datasync.CancelTaskExecutionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CancelTaskExecution cancelled", ctx.Err())
	default:
		return d.CancelTaskExecution(in)
	}
}

func (d *DataSyncDouble) CreateAgent(i0 *datasync.CreateAgentInput) (r0 *datasync.CreateAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAgent", i0)
	r0, _ = returns[0].(*datasync.CreateAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateAgentRequest(i0 *datasync.CreateAgentInput) (r0 *request.Request, r1 *datasync.CreateAgentOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAgentRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateAgentOutput)
	return
}

func (d *DataSyncDouble) CreateAgentWithContext(i0 context.Context, i1 *datasync.CreateAgentInput, i2 ...request.Option) (r0 *datasync.CreateAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateAgentWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateAgentWithContext(ctx context.Context, in *datasync.CreateAgentInput, _ ...request.Option) (*datasync.CreateAgentOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateAgent cancelled", ctx.Err())
	default:
		return d.CreateAgent(in)
	}
}

func (d *DataSyncDouble) CreateLocationEfs(i0 *datasync.CreateLocationEfsInput) (r0 *datasync.CreateLocationEfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationEfs", i0)
	r0, _ = returns[0].(*datasync.CreateLocationEfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateLocationEfsRequest(i0 *datasync.CreateLocationEfsInput) (r0 *request.Request, r1 *datasync.CreateLocationEfsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationEfsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateLocationEfsOutput)
	return
}

func (d *DataSyncDouble) CreateLocationEfsWithContext(i0 context.Context, i1 *datasync.CreateLocationEfsInput, i2 ...request.Option) (r0 *datasync.CreateLocationEfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationEfsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateLocationEfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateLocationEfsWithContext(ctx context.Context, in *datasync.CreateLocationEfsInput, _ ...request.Option) (*datasync.CreateLocationEfsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateLocationEfs cancelled", ctx.Err())
	default:
		return d.CreateLocationEfs(in)
	}
}

func (d *DataSyncDouble) CreateLocationFsxWindows(i0 *datasync.CreateLocationFsxWindowsInput) (r0 *datasync.CreateLocationFsxWindowsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationFsxWindows", i0)
	r0, _ = returns[0].(*datasync.CreateLocationFsxWindowsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateLocationFsxWindowsRequest(i0 *datasync.CreateLocationFsxWindowsInput) (r0 *request.Request, r1 *datasync.CreateLocationFsxWindowsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationFsxWindowsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateLocationFsxWindowsOutput)
	return
}

func (d *DataSyncDouble) CreateLocationFsxWindowsWithContext(i0 context.Context, i1 *datasync.CreateLocationFsxWindowsInput, i2 ...request.Option) (r0 *datasync.CreateLocationFsxWindowsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationFsxWindowsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateLocationFsxWindowsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateLocationFsxWindowsWithContext(ctx context.Context, in *datasync.CreateLocationFsxWindowsInput, _ ...request.Option) (*datasync.CreateLocationFsxWindowsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateLocationFsxWindows cancelled", ctx.Err())
	default:
		return d.CreateLocationFsxWindows(in)
	}
}

func (d *DataSyncDouble) CreateLocationNfs(i0 *datasync.CreateLocationNfsInput) (r0 *datasync.CreateLocationNfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationNfs", i0)
	r0, _ = returns[0].(*datasync.CreateLocationNfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateLocationNfsRequest(i0 *datasync.CreateLocationNfsInput) (r0 *request.Request, r1 *datasync.CreateLocationNfsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationNfsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateLocationNfsOutput)
	return
}

func (d *DataSyncDouble) CreateLocationNfsWithContext(i0 context.Context, i1 *datasync.CreateLocationNfsInput, i2 ...request.Option) (r0 *datasync.CreateLocationNfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationNfsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateLocationNfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateLocationNfsWithContext(ctx context.Context, in *datasync.CreateLocationNfsInput, _ ...request.Option) (*datasync.CreateLocationNfsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateLocationNfs cancelled", ctx.Err())
	default:
		return d.CreateLocationNfs(in)
	}
}

func (d *DataSyncDouble) CreateLocationS3(i0 *datasync.CreateLocationS3Input) (r0 *datasync.CreateLocationS3Output, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationS3", i0)
	r0, _ = returns[0].(*datasync.CreateLocationS3Output)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateLocationS3Request(i0 *datasync.CreateLocationS3Input) (r0 *request.Request, r1 *datasync.CreateLocationS3Output) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationS3Request", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateLocationS3Output)
	return
}

func (d *DataSyncDouble) CreateLocationS3WithContext(i0 context.Context, i1 *datasync.CreateLocationS3Input, i2 ...request.Option) (r0 *datasync.CreateLocationS3Output, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationS3WithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateLocationS3Output)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateLocationS3WithContext(ctx context.Context, in *datasync.CreateLocationS3Input, _ ...request.Option) (*datasync.CreateLocationS3Output, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateLocationS3 cancelled", ctx.Err())
	default:
		return d.CreateLocationS3(in)
	}
}

func (d *DataSyncDouble) CreateLocationSmb(i0 *datasync.CreateLocationSmbInput) (r0 *datasync.CreateLocationSmbOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationSmb", i0)
	r0, _ = returns[0].(*datasync.CreateLocationSmbOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateLocationSmbRequest(i0 *datasync.CreateLocationSmbInput) (r0 *request.Request, r1 *datasync.CreateLocationSmbOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationSmbRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateLocationSmbOutput)
	return
}

func (d *DataSyncDouble) CreateLocationSmbWithContext(i0 context.Context, i1 *datasync.CreateLocationSmbInput, i2 ...request.Option) (r0 *datasync.CreateLocationSmbOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateLocationSmbWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateLocationSmbOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateLocationSmbWithContext(ctx context.Context, in *datasync.CreateLocationSmbInput, _ ...request.Option) (*datasync.CreateLocationSmbOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateLocationSmb cancelled", ctx.Err())
	default:
		return d.CreateLocationSmb(in)
	}
}

func (d *DataSyncDouble) CreateTask(i0 *datasync.CreateTaskInput) (r0 *datasync.CreateTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateTask", i0)
	r0, _ = returns[0].(*datasync.CreateTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) CreateTaskRequest(i0 *datasync.CreateTaskInput) (r0 *request.Request, r1 *datasync.CreateTaskOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateTaskRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.CreateTaskOutput)
	return
}

func (d *DataSyncDouble) CreateTaskWithContext(i0 context.Context, i1 *datasync.CreateTaskInput, i2 ...request.Option) (r0 *datasync.CreateTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateTaskWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.CreateTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeCreateTaskWithContext(ctx context.Context, in *datasync.CreateTaskInput, _ ...request.Option) (*datasync.CreateTaskOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "CreateTask cancelled", ctx.Err())
	default:
		return d.CreateTask(in)
	}
}

func (d *DataSyncDouble) DeleteAgent(i0 *datasync.DeleteAgentInput) (r0 *datasync.DeleteAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAgent", i0)
	r0, _ = returns[0].(*datasync.DeleteAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DeleteAgentRequest(i0 *datasync.DeleteAgentInput) (r0 *request.Request, r1 *datasync.DeleteAgentOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAgentRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DeleteAgentOutput)
	return
}

func (d *DataSyncDouble) DeleteAgentWithContext(i0 context.Context, i1 *datasync.DeleteAgentInput, i2 ...request.Option) (r0 *datasync.DeleteAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAgentWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DeleteAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDeleteAgentWithContext(ctx context.Context, in *datasync.DeleteAgentInput, _ ...request.Option) (*datasync.DeleteAgentOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteAgent cancelled", ctx.Err())
	default:
		return d.DeleteAgent(in)
	}
}

func (d *DataSyncDouble) DeleteLocation(i0 *datasync.DeleteLocationInput) (r0 *datasync.DeleteLocationOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLocation", i0)
	r0, _ = returns[0].(*datasync.DeleteLocationOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DeleteLocationRequest(i0 *datasync.DeleteLocationInput) (r0 *request.Request, r1 *datasync.DeleteLocationOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLocationRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DeleteLocationOutput)
	return
}

func (d *DataSyncDouble) DeleteLocationWithContext(i0 context.Context, i1 *datasync.DeleteLocationInput, i2 ...request.Option) (r0 *datasync.DeleteLocationOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteLocationWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DeleteLocationOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDeleteLocationWithContext(ctx context.Context, in *datasync.DeleteLocationInput, _ ...request.Option) (*datasync.DeleteLocationOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteLocation cancelled", ctx.Err())
	default:
		return d.DeleteLocation(in)
	}
}

func (d *DataSyncDouble) DeleteTask(i0 *datasync.DeleteTaskInput) (r0 *datasync.DeleteTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteTask", i0)
	r0, _ = returns[0].(*datasync.DeleteTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DeleteTaskRequest(i0 *datasync.DeleteTaskInput) (r0 *request.Request, r1 *datasync.DeleteTaskOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteTaskRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DeleteTaskOutput)
	return
}

func (d *DataSyncDouble) DeleteTaskWithContext(i0 context.Context, i1 *datasync.DeleteTaskInput, i2 ...request.Option) (r0 *datasync.DeleteTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteTaskWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DeleteTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDeleteTaskWithContext(ctx context.Context, in *datasync.DeleteTaskInput, _ ...request.Option) (*datasync.DeleteTaskOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DeleteTask cancelled", ctx.Err())
	default:
		return d.DeleteTask(in)
	}
}

func (d *DataSyncDouble) DescribeAgent(i0 *datasync.DescribeAgentInput) (r0 *datasync.DescribeAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAgent", i0)
	r0, _ = returns[0].(*datasync.DescribeAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeAgentRequest(i0 *datasync.DescribeAgentInput) (r0 *request.Request, r1 *datasync.DescribeAgentOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAgentRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeAgentOutput)
	return
}

func (d *DataSyncDouble) DescribeAgentWithContext(i0 context.Context, i1 *datasync.DescribeAgentInput, i2 ...request.Option) (r0 *datasync.DescribeAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAgentWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeAgentWithContext(ctx context.Context, in *datasync.DescribeAgentInput, _ ...request.Option) (*datasync.DescribeAgentOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeAgent cancelled", ctx.Err())
	default:
		return d.DescribeAgent(in)
	}
}

func (d *DataSyncDouble) DescribeLocationEfs(i0 *datasync.DescribeLocationEfsInput) (r0 *datasync.DescribeLocationEfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationEfs", i0)
	r0, _ = returns[0].(*datasync.DescribeLocationEfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeLocationEfsRequest(i0 *datasync.DescribeLocationEfsInput) (r0 *request.Request, r1 *datasync.DescribeLocationEfsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationEfsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeLocationEfsOutput)
	return
}

func (d *DataSyncDouble) DescribeLocationEfsWithContext(i0 context.Context, i1 *datasync.DescribeLocationEfsInput, i2 ...request.Option) (r0 *datasync.DescribeLocationEfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationEfsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeLocationEfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeLocationEfsWithContext(ctx context.Context, in *datasync.DescribeLocationEfsInput, _ ...request.Option) (*datasync.DescribeLocationEfsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeLocationEfs cancelled", ctx.Err())
	default:
		return d.DescribeLocationEfs(in)
	}
}

func (d *DataSyncDouble) DescribeLocationFsxWindows(i0 *datasync.DescribeLocationFsxWindowsInput) (r0 *datasync.DescribeLocationFsxWindowsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationFsxWindows", i0)
	r0, _ = returns[0].(*datasync.DescribeLocationFsxWindowsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeLocationFsxWindowsRequest(i0 *datasync.DescribeLocationFsxWindowsInput) (r0 *request.Request, r1 *datasync.DescribeLocationFsxWindowsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationFsxWindowsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeLocationFsxWindowsOutput)
	return
}

func (d *DataSyncDouble) DescribeLocationFsxWindowsWithContext(i0 context.Context, i1 *datasync.DescribeLocationFsxWindowsInput, i2 ...request.Option) (r0 *datasync.DescribeLocationFsxWindowsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationFsxWindowsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeLocationFsxWindowsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeLocationFsxWindowsWithContext(ctx context.Context, in *datasync.DescribeLocationFsxWindowsInput, _ ...request.Option) (*datasync.DescribeLocationFsxWindowsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeLocationFsxWindows cancelled", ctx.Err())
	default:
		return d.DescribeLocationFsxWindows(in)
	}
}

func (d *DataSyncDouble) DescribeLocationNfs(i0 *datasync.DescribeLocationNfsInput) (r0 *datasync.DescribeLocationNfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationNfs", i0)
	r0, _ = returns[0].(*datasync.DescribeLocationNfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeLocationNfsRequest(i0 *datasync.DescribeLocationNfsInput) (r0 *request.Request, r1 *datasync.DescribeLocationNfsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationNfsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeLocationNfsOutput)
	return
}

func (d *DataSyncDouble) DescribeLocationNfsWithContext(i0 context.Context, i1 *datasync.DescribeLocationNfsInput, i2 ...request.Option) (r0 *datasync.DescribeLocationNfsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationNfsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeLocationNfsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeLocationNfsWithContext(ctx context.Context, in *datasync.DescribeLocationNfsInput, _ ...request.Option) (*datasync.DescribeLocationNfsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeLocationNfs cancelled", ctx.Err())
	default:
		return d.DescribeLocationNfs(in)
	}
}

func (d *DataSyncDouble) DescribeLocationS3(i0 *datasync.DescribeLocationS3Input) (r0 *datasync.DescribeLocationS3Output, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationS3", i0)
	r0, _ = returns[0].(*datasync.DescribeLocationS3Output)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeLocationS3Request(i0 *datasync.DescribeLocationS3Input) (r0 *request.Request, r1 *datasync.DescribeLocationS3Output) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationS3Request", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeLocationS3Output)
	return
}

func (d *DataSyncDouble) DescribeLocationS3WithContext(i0 context.Context, i1 *datasync.DescribeLocationS3Input, i2 ...request.Option) (r0 *datasync.DescribeLocationS3Output, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationS3WithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeLocationS3Output)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeLocationS3WithContext(ctx context.Context, in *datasync.DescribeLocationS3Input, _ ...request.Option) (*datasync.DescribeLocationS3Output, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeLocationS3 cancelled", ctx.Err())
	default:
		return d.DescribeLocationS3(in)
	}
}

func (d *DataSyncDouble) DescribeLocationSmb(i0 *datasync.DescribeLocationSmbInput) (r0 *datasync.DescribeLocationSmbOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationSmb", i0)
	r0, _ = returns[0].(*datasync.DescribeLocationSmbOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeLocationSmbRequest(i0 *datasync.DescribeLocationSmbInput) (r0 *request.Request, r1 *datasync.DescribeLocationSmbOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationSmbRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeLocationSmbOutput)
	return
}

func (d *DataSyncDouble) DescribeLocationSmbWithContext(i0 context.Context, i1 *datasync.DescribeLocationSmbInput, i2 ...request.Option) (r0 *datasync.DescribeLocationSmbOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeLocationSmbWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeLocationSmbOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeLocationSmbWithContext(ctx context.Context, in *datasync.DescribeLocationSmbInput, _ ...request.Option) (*datasync.DescribeLocationSmbOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeLocationSmb cancelled", ctx.Err())
	default:
		return d.DescribeLocationSmb(in)
	}
}

func (d *DataSyncDouble) DescribeTask(i0 *datasync.DescribeTaskInput) (r0 *datasync.DescribeTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTask", i0)
	r0, _ = returns[0].(*datasync.DescribeTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeTaskExecution(i0 *datasync.DescribeTaskExecutionInput) (r0 *datasync.DescribeTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTaskExecution", i0)
	r0, _ = returns[0].(*datasync.DescribeTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) DescribeTaskExecutionRequest(i0 *datasync.DescribeTaskExecutionInput) (r0 *request.Request, r1 *datasync.DescribeTaskExecutionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTaskExecutionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeTaskExecutionOutput)
	return
}

func (d *DataSyncDouble) DescribeTaskExecutionWithContext(i0 context.Context, i1 *datasync.DescribeTaskExecutionInput, i2 ...request.Option) (r0 *datasync.DescribeTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTaskExecutionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeTaskExecutionWithContext(ctx context.Context, in *datasync.DescribeTaskExecutionInput, _ ...request.Option) (*datasync.DescribeTaskExecutionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeTaskExecution cancelled", ctx.Err())
	default:
		return d.DescribeTaskExecution(in)
	}
}

func (d *DataSyncDouble) DescribeTaskRequest(i0 *datasync.DescribeTaskInput) (r0 *request.Request, r1 *datasync.DescribeTaskOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTaskRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.DescribeTaskOutput)
	return
}

func (d *DataSyncDouble) DescribeTaskWithContext(i0 context.Context, i1 *datasync.DescribeTaskInput, i2 ...request.Option) (r0 *datasync.DescribeTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeTaskWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.DescribeTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeDescribeTaskWithContext(ctx context.Context, in *datasync.DescribeTaskInput, _ ...request.Option) (*datasync.DescribeTaskOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "DescribeTask cancelled", ctx.Err())
	default:
		return d.DescribeTask(in)
	}
}

func (d *DataSyncDouble) ListAgents(i0 *datasync.ListAgentsInput) (r0 *datasync.ListAgentsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAgents", i0)
	r0, _ = returns[0].(*datasync.ListAgentsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) ListAgentsPages(i0 *datasync.ListAgentsInput, i1 func(*datasync.ListAgentsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAgentsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListAgentsPages(in *datasync.ListAgentsInput, pager func(*datasync.ListAgentsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListAgents", paginators, in, pager)
}

func (d *DataSyncDouble) ListAgentsPagesWithContext(i0 context.Context, i1 *datasync.ListAgentsInput, i2 func(*datasync.ListAgentsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAgentsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListAgentsPagesWithContext(ctx context.Context, in *datasync.ListAgentsInput, pager func(*datasync.ListAgentsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListAgents", paginators, ctx, in, pager, options...)
}

func (d *DataSyncDouble) ListAgentsRequest(i0 *datasync.ListAgentsInput) (r0 *request.Request, r1 *datasync.ListAgentsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAgentsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.ListAgentsOutput)
	return
}

func (d *DataSyncDouble) ListAgentsWithContext(i0 context.Context, i1 *datasync.ListAgentsInput, i2 ...request.Option) (r0 *datasync.ListAgentsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAgentsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.ListAgentsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeListAgentsWithContext(ctx context.Context, in *datasync.ListAgentsInput, _ ...request.Option) (*datasync.ListAgentsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListAgents cancelled", ctx.Err())
	default:
		return d.ListAgents(in)
	}
}

func (d *DataSyncDouble) ListLocations(i0 *datasync.ListLocationsInput) (r0 *datasync.ListLocationsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLocations", i0)
	r0, _ = returns[0].(*datasync.ListLocationsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) ListLocationsPages(i0 *datasync.ListLocationsInput, i1 func(*datasync.ListLocationsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLocationsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListLocationsPages(in *datasync.ListLocationsInput, pager func(*datasync.ListLocationsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListLocations", paginators, in, pager)
}

func (d *DataSyncDouble) ListLocationsPagesWithContext(i0 context.Context, i1 *datasync.ListLocationsInput, i2 func(*datasync.ListLocationsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLocationsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListLocationsPagesWithContext(ctx context.Context, in *datasync.ListLocationsInput, pager func(*datasync.ListLocationsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListLocations", paginators, ctx, in, pager, options...)
}

func (d *DataSyncDouble) ListLocationsRequest(i0 *datasync.ListLocationsInput) (r0 *request.Request, r1 *datasync.ListLocationsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLocationsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.ListLocationsOutput)
	return
}

func (d *DataSyncDouble) ListLocationsWithContext(i0 context.Context, i1 *datasync.ListLocationsInput, i2 ...request.Option) (r0 *datasync.ListLocationsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListLocationsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.ListLocationsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeListLocationsWithContext(ctx context.Context, in *datasync.ListLocationsInput, _ ...request.Option) (*datasync.ListLocationsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListLocations cancelled", ctx.Err())
	default:
		return d.ListLocations(in)
	}
}

func (d *DataSyncDouble) ListTagsForResource(i0 *datasync.ListTagsForResourceInput) (r0 *datasync.ListTagsForResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResource", i0)
	r0, _ = returns[0].(*datasync.ListTagsForResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) ListTagsForResourcePages(i0 *datasync.ListTagsForResourceInput, i1 func(*datasync.ListTagsForResourceOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourcePages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTagsForResourcePages(in *datasync.ListTagsForResourceInput, pager func(*datasync.ListTagsForResourceOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListTagsForResource", paginators, in, pager)
}

func (d *DataSyncDouble) ListTagsForResourcePagesWithContext(i0 context.Context, i1 *datasync.ListTagsForResourceInput, i2 func(*datasync.ListTagsForResourceOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourcePagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTagsForResourcePagesWithContext(ctx context.Context, in *datasync.ListTagsForResourceInput, pager func(*datasync.ListTagsForResourceOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListTagsForResource", paginators, ctx, in, pager, options...)
}

func (d *DataSyncDouble) ListTagsForResourceRequest(i0 *datasync.ListTagsForResourceInput) (r0 *request.Request, r1 *datasync.ListTagsForResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.ListTagsForResourceOutput)
	return
}

func (d *DataSyncDouble) ListTagsForResourceWithContext(i0 context.Context, i1 *datasync.ListTagsForResourceInput, i2 ...request.Option) (r0 *datasync.ListTagsForResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTagsForResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.ListTagsForResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeListTagsForResourceWithContext(ctx context.Context, in *datasync.ListTagsForResourceInput, _ ...request.Option) (*datasync.ListTagsForResourceOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListTagsForResource cancelled", ctx.Err())
	default:
		return d.ListTagsForResource(in)
	}
}

func (d *DataSyncDouble) ListTaskExecutions(i0 *datasync.ListTaskExecutionsInput) (r0 *datasync.ListTaskExecutionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTaskExecutions", i0)
	r0, _ = returns[0].(*datasync.ListTaskExecutionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) ListTaskExecutionsPages(i0 *datasync.ListTaskExecutionsInput, i1 func(*datasync.ListTaskExecutionsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTaskExecutionsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTaskExecutionsPages(in *datasync.ListTaskExecutionsInput, pager func(*datasync.ListTaskExecutionsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListTaskExecutions", paginators, in, pager)
}

func (d *DataSyncDouble) ListTaskExecutionsPagesWithContext(i0 context.Context, i1 *datasync.ListTaskExecutionsInput, i2 func(*datasync.ListTaskExecutionsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTaskExecutionsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTaskExecutionsPagesWithContext(ctx context.Context, in *datasync.ListTaskExecutionsInput, pager func(*datasync.ListTaskExecutionsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListTaskExecutions", paginators, ctx, in, pager, options...)
}

func (d *DataSyncDouble) ListTaskExecutionsRequest(i0 *datasync.ListTaskExecutionsInput) (r0 *request.Request, r1 *datasync.ListTaskExecutionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTaskExecutionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.ListTaskExecutionsOutput)
	return
}

func (d *DataSyncDouble) ListTaskExecutionsWithContext(i0 context.Context, i1 *datasync.ListTaskExecutionsInput, i2 ...request.Option) (r0 *datasync.ListTaskExecutionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTaskExecutionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.ListTaskExecutionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeListTaskExecutionsWithContext(ctx context.Context, in *datasync.ListTaskExecutionsInput, _ ...request.Option) (*datasync.ListTaskExecutionsOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListTaskExecutions cancelled", ctx.Err())
	default:
		return d.ListTaskExecutions(in)
	}
}

func (d *DataSyncDouble) ListTasks(i0 *datasync.ListTasksInput) (r0 *datasync.ListTasksOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTasks", i0)
	r0, _ = returns[0].(*datasync.ListTasksOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) ListTasksPages(i0 *datasync.ListTasksInput, i1 func(*datasync.ListTasksOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTasksPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTasksPages(in *datasync.ListTasksInput, pager func(*datasync.ListTasksOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListTasks", paginators, in, pager)
}

func (d *DataSyncDouble) ListTasksPagesWithContext(i0 context.Context, i1 *datasync.ListTasksInput, i2 func(*datasync.ListTasksOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTasksPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataSyncDouble) fakeListTasksPagesWithContext(ctx context.Context, in *datasync.ListTasksInput, pager func(*datasync.ListTasksOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListTasks", paginators, ctx, in, pager, options...)
}

func (d *DataSyncDouble) ListTasksRequest(i0 *datasync.ListTasksInput) (r0 *request.Request, r1 *datasync.ListTasksOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTasksRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.ListTasksOutput)
	return
}

func (d *DataSyncDouble) ListTasksWithContext(i0 context.Context, i1 *datasync.ListTasksInput, i2 ...request.Option) (r0 *datasync.ListTasksOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListTasksWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.ListTasksOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeListTasksWithContext(ctx context.Context, in *datasync.ListTasksInput, _ ...request.Option) (*datasync.ListTasksOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "ListTasks cancelled", ctx.Err())
	default:
		return d.ListTasks(in)
	}
}

func (d *DataSyncDouble) StartTaskExecution(i0 *datasync.StartTaskExecutionInput) (r0 *datasync.StartTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartTaskExecution", i0)
	r0, _ = returns[0].(*datasync.StartTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) StartTaskExecutionRequest(i0 *datasync.StartTaskExecutionInput) (r0 *request.Request, r1 *datasync.StartTaskExecutionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartTaskExecutionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.StartTaskExecutionOutput)
	return
}

func (d *DataSyncDouble) StartTaskExecutionWithContext(i0 context.Context, i1 *datasync.StartTaskExecutionInput, i2 ...request.Option) (r0 *datasync.StartTaskExecutionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartTaskExecutionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.StartTaskExecutionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeStartTaskExecutionWithContext(ctx context.Context, in *datasync.StartTaskExecutionInput, _ ...request.Option) (*datasync.StartTaskExecutionOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "StartTaskExecution cancelled", ctx.Err())
	default:
		return d.StartTaskExecution(in)
	}
}

func (d *DataSyncDouble) TagResource(i0 *datasync.TagResourceInput) (r0 *datasync.TagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResource", i0)
	r0, _ = returns[0].(*datasync.TagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) TagResourceRequest(i0 *datasync.TagResourceInput) (r0 *request.Request, r1 *datasync.TagResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.TagResourceOutput)
	return
}

func (d *DataSyncDouble) TagResourceWithContext(i0 context.Context, i1 *datasync.TagResourceInput, i2 ...request.Option) (r0 *datasync.TagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("TagResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.TagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeTagResourceWithContext(ctx context.Context, in *datasync.TagResourceInput, _ ...request.Option) (*datasync.TagResourceOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "TagResource cancelled", ctx.Err())
	default:
		return d.TagResource(in)
	}
}

func (d *DataSyncDouble) UntagResource(i0 *datasync.UntagResourceInput) (r0 *datasync.UntagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResource", i0)
	r0, _ = returns[0].(*datasync.UntagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) UntagResourceRequest(i0 *datasync.UntagResourceInput) (r0 *request.Request, r1 *datasync.UntagResourceOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResourceRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.UntagResourceOutput)
	return
}

func (d *DataSyncDouble) UntagResourceWithContext(i0 context.Context, i1 *datasync.UntagResourceInput, i2 ...request.Option) (r0 *datasync.UntagResourceOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UntagResourceWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.UntagResourceOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeUntagResourceWithContext(ctx context.Context, in *datasync.UntagResourceInput, _ ...request.Option) (*datasync.UntagResourceOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UntagResource cancelled", ctx.Err())
	default:
		return d.UntagResource(in)
	}
}

func (d *DataSyncDouble) UpdateAgent(i0 *datasync.UpdateAgentInput) (r0 *datasync.UpdateAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAgent", i0)
	r0, _ = returns[0].(*datasync.UpdateAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) UpdateAgentRequest(i0 *datasync.UpdateAgentInput) (r0 *request.Request, r1 *datasync.UpdateAgentOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAgentRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.UpdateAgentOutput)
	return
}

func (d *DataSyncDouble) UpdateAgentWithContext(i0 context.Context, i1 *datasync.UpdateAgentInput, i2 ...request.Option) (r0 *datasync.UpdateAgentOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAgentWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.UpdateAgentOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeUpdateAgentWithContext(ctx context.Context, in *datasync.UpdateAgentInput, _ ...request.Option) (*datasync.UpdateAgentOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateAgent cancelled", ctx.Err())
	default:
		return d.UpdateAgent(in)
	}
}

func (d *DataSyncDouble) UpdateTask(i0 *datasync.UpdateTaskInput) (r0 *datasync.UpdateTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateTask", i0)
	r0, _ = returns[0].(*datasync.UpdateTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) UpdateTaskRequest(i0 *datasync.UpdateTaskInput) (r0 *request.Request, r1 *datasync.UpdateTaskOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateTaskRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*datasync.UpdateTaskOutput)
	return
}

func (d *DataSyncDouble) UpdateTaskWithContext(i0 context.Context, i1 *datasync.UpdateTaskInput, i2 ...request.Option) (r0 *datasync.UpdateTaskOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateTaskWithContext", i0, i1, i2)
	r0, _ = returns[0].(*datasync.UpdateTaskOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataSyncDouble) fakeUpdateTaskWithContext(ctx context.Context, in *datasync.UpdateTaskInput, _ ...request.Option) (*datasync.UpdateTaskOutput, error) {

	select {
	case <-ctx.Done():
		return nil, awserr.New(request.CanceledErrorCode, "UpdateTask cancelled", ctx.Err())
	default:
		return d.UpdateTask(in)
	}
}