double.go

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

// Package dataexchangedouble provides a TestDouble implementation of dataexchangeiface.DataExchangeAPI
package dataexchangedouble

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/dataexchange"
	"github.com/aws/aws-sdk-go/service/dataexchange/dataexchangeiface"
	"github.com/lwoggardner/awsdouble"
	"github.com/lwoggardner/godouble/godouble"
)

// DataExchangeDouble is TestDouble for dataexchangeiface.DataExchangeAPI
type DataExchangeDouble struct {
	dataexchangeiface.DataExchangeAPI
	*awsdouble.AWSTestDouble
}

// Constructor for DataExchangeDouble
// 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)) *DataExchangeDouble {
	result := &DataExchangeDouble{}

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

	result.AWSTestDouble = awsdouble.NewDouble(t, (*dataexchangeiface.DataExchangeAPI)(nil), configurators...)
	return result
}

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

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

	case "CancelJobWithContext":
		return m.Fake(d.fakeCancelJobWithContext)

	case "CreateDataSetWithContext":
		return m.Fake(d.fakeCreateDataSetWithContext)

	case "CreateJobWithContext":
		return m.Fake(d.fakeCreateJobWithContext)

	case "CreateRevisionWithContext":
		return m.Fake(d.fakeCreateRevisionWithContext)

	case "DeleteAssetWithContext":
		return m.Fake(d.fakeDeleteAssetWithContext)

	case "DeleteDataSetWithContext":
		return m.Fake(d.fakeDeleteDataSetWithContext)

	case "DeleteRevisionWithContext":
		return m.Fake(d.fakeDeleteRevisionWithContext)

	case "GetAssetWithContext":
		return m.Fake(d.fakeGetAssetWithContext)

	case "GetDataSetWithContext":
		return m.Fake(d.fakeGetDataSetWithContext)

	case "GetJobWithContext":
		return m.Fake(d.fakeGetJobWithContext)

	case "GetRevisionWithContext":
		return m.Fake(d.fakeGetRevisionWithContext)

	case "ListDataSetRevisionsPages":
		return m.Fake(d.fakeListDataSetRevisionsPages)

	case "ListDataSetRevisionsPagesWithContext":
		return m.Fake(d.fakeListDataSetRevisionsPagesWithContext)

	case "ListDataSetRevisionsWithContext":
		return m.Fake(d.fakeListDataSetRevisionsWithContext)

	case "ListDataSetsPages":
		return m.Fake(d.fakeListDataSetsPages)

	case "ListDataSetsPagesWithContext":
		return m.Fake(d.fakeListDataSetsPagesWithContext)

	case "ListDataSetsWithContext":
		return m.Fake(d.fakeListDataSetsWithContext)

	case "ListJobsPages":
		return m.Fake(d.fakeListJobsPages)

	case "ListJobsPagesWithContext":
		return m.Fake(d.fakeListJobsPagesWithContext)

	case "ListJobsWithContext":
		return m.Fake(d.fakeListJobsWithContext)

	case "ListRevisionAssetsPages":
		return m.Fake(d.fakeListRevisionAssetsPages)

	case "ListRevisionAssetsPagesWithContext":
		return m.Fake(d.fakeListRevisionAssetsPagesWithContext)

	case "ListRevisionAssetsWithContext":
		return m.Fake(d.fakeListRevisionAssetsWithContext)

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

	case "StartJobWithContext":
		return m.Fake(d.fakeStartJobWithContext)

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

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

	case "UpdateAssetWithContext":
		return m.Fake(d.fakeUpdateAssetWithContext)

	case "UpdateDataSetWithContext":
		return m.Fake(d.fakeUpdateDataSetWithContext)

	case "UpdateRevisionWithContext":
		return m.Fake(d.fakeUpdateRevisionWithContext)

	default:
		return nil
	}
}

func (d *DataExchangeDouble) CancelJob(i0 *dataexchange.CancelJobInput) (r0 *dataexchange.CancelJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelJob", i0)
	r0, _ = returns[0].(*dataexchange.CancelJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) CancelJobRequest(i0 *dataexchange.CancelJobInput) (r0 *request.Request, r1 *dataexchange.CancelJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.CancelJobOutput)
	return
}

func (d *DataExchangeDouble) CancelJobWithContext(i0 context.Context, i1 *dataexchange.CancelJobInput, i2 ...request.Option) (r0 *dataexchange.CancelJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CancelJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.CancelJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeCancelJobWithContext(ctx context.Context, in *dataexchange.CancelJobInput, _ ...request.Option) (*dataexchange.CancelJobOutput, error) {

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

func (d *DataExchangeDouble) CreateDataSet(i0 *dataexchange.CreateDataSetInput) (r0 *dataexchange.CreateDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDataSet", i0)
	r0, _ = returns[0].(*dataexchange.CreateDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) CreateDataSetRequest(i0 *dataexchange.CreateDataSetInput) (r0 *request.Request, r1 *dataexchange.CreateDataSetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDataSetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.CreateDataSetOutput)
	return
}

func (d *DataExchangeDouble) CreateDataSetWithContext(i0 context.Context, i1 *dataexchange.CreateDataSetInput, i2 ...request.Option) (r0 *dataexchange.CreateDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateDataSetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.CreateDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeCreateDataSetWithContext(ctx context.Context, in *dataexchange.CreateDataSetInput, _ ...request.Option) (*dataexchange.CreateDataSetOutput, error) {

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

func (d *DataExchangeDouble) CreateJob(i0 *dataexchange.CreateJobInput) (r0 *dataexchange.CreateJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateJob", i0)
	r0, _ = returns[0].(*dataexchange.CreateJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) CreateJobRequest(i0 *dataexchange.CreateJobInput) (r0 *request.Request, r1 *dataexchange.CreateJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.CreateJobOutput)
	return
}

func (d *DataExchangeDouble) CreateJobWithContext(i0 context.Context, i1 *dataexchange.CreateJobInput, i2 ...request.Option) (r0 *dataexchange.CreateJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.CreateJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeCreateJobWithContext(ctx context.Context, in *dataexchange.CreateJobInput, _ ...request.Option) (*dataexchange.CreateJobOutput, error) {

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

func (d *DataExchangeDouble) CreateRevision(i0 *dataexchange.CreateRevisionInput) (r0 *dataexchange.CreateRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRevision", i0)
	r0, _ = returns[0].(*dataexchange.CreateRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) CreateRevisionRequest(i0 *dataexchange.CreateRevisionInput) (r0 *request.Request, r1 *dataexchange.CreateRevisionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRevisionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.CreateRevisionOutput)
	return
}

func (d *DataExchangeDouble) CreateRevisionWithContext(i0 context.Context, i1 *dataexchange.CreateRevisionInput, i2 ...request.Option) (r0 *dataexchange.CreateRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateRevisionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.CreateRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeCreateRevisionWithContext(ctx context.Context, in *dataexchange.CreateRevisionInput, _ ...request.Option) (*dataexchange.CreateRevisionOutput, error) {

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

func (d *DataExchangeDouble) DeleteAsset(i0 *dataexchange.DeleteAssetInput) (r0 *dataexchange.DeleteAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAsset", i0)
	r0, _ = returns[0].(*dataexchange.DeleteAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) DeleteAssetRequest(i0 *dataexchange.DeleteAssetInput) (r0 *request.Request, r1 *dataexchange.DeleteAssetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAssetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.DeleteAssetOutput)
	return
}

func (d *DataExchangeDouble) DeleteAssetWithContext(i0 context.Context, i1 *dataexchange.DeleteAssetInput, i2 ...request.Option) (r0 *dataexchange.DeleteAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteAssetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.DeleteAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeDeleteAssetWithContext(ctx context.Context, in *dataexchange.DeleteAssetInput, _ ...request.Option) (*dataexchange.DeleteAssetOutput, error) {

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

func (d *DataExchangeDouble) DeleteDataSet(i0 *dataexchange.DeleteDataSetInput) (r0 *dataexchange.DeleteDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDataSet", i0)
	r0, _ = returns[0].(*dataexchange.DeleteDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) DeleteDataSetRequest(i0 *dataexchange.DeleteDataSetInput) (r0 *request.Request, r1 *dataexchange.DeleteDataSetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDataSetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.DeleteDataSetOutput)
	return
}

func (d *DataExchangeDouble) DeleteDataSetWithContext(i0 context.Context, i1 *dataexchange.DeleteDataSetInput, i2 ...request.Option) (r0 *dataexchange.DeleteDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteDataSetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.DeleteDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeDeleteDataSetWithContext(ctx context.Context, in *dataexchange.DeleteDataSetInput, _ ...request.Option) (*dataexchange.DeleteDataSetOutput, error) {

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

func (d *DataExchangeDouble) DeleteRevision(i0 *dataexchange.DeleteRevisionInput) (r0 *dataexchange.DeleteRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRevision", i0)
	r0, _ = returns[0].(*dataexchange.DeleteRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) DeleteRevisionRequest(i0 *dataexchange.DeleteRevisionInput) (r0 *request.Request, r1 *dataexchange.DeleteRevisionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRevisionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.DeleteRevisionOutput)
	return
}

func (d *DataExchangeDouble) DeleteRevisionWithContext(i0 context.Context, i1 *dataexchange.DeleteRevisionInput, i2 ...request.Option) (r0 *dataexchange.DeleteRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteRevisionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.DeleteRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeDeleteRevisionWithContext(ctx context.Context, in *dataexchange.DeleteRevisionInput, _ ...request.Option) (*dataexchange.DeleteRevisionOutput, error) {

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

func (d *DataExchangeDouble) GetAsset(i0 *dataexchange.GetAssetInput) (r0 *dataexchange.GetAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAsset", i0)
	r0, _ = returns[0].(*dataexchange.GetAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) GetAssetRequest(i0 *dataexchange.GetAssetInput) (r0 *request.Request, r1 *dataexchange.GetAssetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAssetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.GetAssetOutput)
	return
}

func (d *DataExchangeDouble) GetAssetWithContext(i0 context.Context, i1 *dataexchange.GetAssetInput, i2 ...request.Option) (r0 *dataexchange.GetAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetAssetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.GetAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeGetAssetWithContext(ctx context.Context, in *dataexchange.GetAssetInput, _ ...request.Option) (*dataexchange.GetAssetOutput, error) {

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

func (d *DataExchangeDouble) GetDataSet(i0 *dataexchange.GetDataSetInput) (r0 *dataexchange.GetDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDataSet", i0)
	r0, _ = returns[0].(*dataexchange.GetDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) GetDataSetRequest(i0 *dataexchange.GetDataSetInput) (r0 *request.Request, r1 *dataexchange.GetDataSetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDataSetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.GetDataSetOutput)
	return
}

func (d *DataExchangeDouble) GetDataSetWithContext(i0 context.Context, i1 *dataexchange.GetDataSetInput, i2 ...request.Option) (r0 *dataexchange.GetDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetDataSetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.GetDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeGetDataSetWithContext(ctx context.Context, in *dataexchange.GetDataSetInput, _ ...request.Option) (*dataexchange.GetDataSetOutput, error) {

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

func (d *DataExchangeDouble) GetJob(i0 *dataexchange.GetJobInput) (r0 *dataexchange.GetJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetJob", i0)
	r0, _ = returns[0].(*dataexchange.GetJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) GetJobRequest(i0 *dataexchange.GetJobInput) (r0 *request.Request, r1 *dataexchange.GetJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.GetJobOutput)
	return
}

func (d *DataExchangeDouble) GetJobWithContext(i0 context.Context, i1 *dataexchange.GetJobInput, i2 ...request.Option) (r0 *dataexchange.GetJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.GetJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeGetJobWithContext(ctx context.Context, in *dataexchange.GetJobInput, _ ...request.Option) (*dataexchange.GetJobOutput, error) {

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

func (d *DataExchangeDouble) GetRevision(i0 *dataexchange.GetRevisionInput) (r0 *dataexchange.GetRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetRevision", i0)
	r0, _ = returns[0].(*dataexchange.GetRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) GetRevisionRequest(i0 *dataexchange.GetRevisionInput) (r0 *request.Request, r1 *dataexchange.GetRevisionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetRevisionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.GetRevisionOutput)
	return
}

func (d *DataExchangeDouble) GetRevisionWithContext(i0 context.Context, i1 *dataexchange.GetRevisionInput, i2 ...request.Option) (r0 *dataexchange.GetRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetRevisionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.GetRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeGetRevisionWithContext(ctx context.Context, in *dataexchange.GetRevisionInput, _ ...request.Option) (*dataexchange.GetRevisionOutput, error) {

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

func (d *DataExchangeDouble) ListDataSetRevisions(i0 *dataexchange.ListDataSetRevisionsInput) (r0 *dataexchange.ListDataSetRevisionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetRevisions", i0)
	r0, _ = returns[0].(*dataexchange.ListDataSetRevisionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) ListDataSetRevisionsPages(i0 *dataexchange.ListDataSetRevisionsInput, i1 func(*dataexchange.ListDataSetRevisionsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetRevisionsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetRevisionsPages(in *dataexchange.ListDataSetRevisionsInput, pager func(*dataexchange.ListDataSetRevisionsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDataSetRevisions", paginators, in, pager)
}

func (d *DataExchangeDouble) ListDataSetRevisionsPagesWithContext(i0 context.Context, i1 *dataexchange.ListDataSetRevisionsInput, i2 func(*dataexchange.ListDataSetRevisionsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetRevisionsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetRevisionsPagesWithContext(ctx context.Context, in *dataexchange.ListDataSetRevisionsInput, pager func(*dataexchange.ListDataSetRevisionsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDataSetRevisions", paginators, ctx, in, pager, options...)
}

func (d *DataExchangeDouble) ListDataSetRevisionsRequest(i0 *dataexchange.ListDataSetRevisionsInput) (r0 *request.Request, r1 *dataexchange.ListDataSetRevisionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetRevisionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.ListDataSetRevisionsOutput)
	return
}

func (d *DataExchangeDouble) ListDataSetRevisionsWithContext(i0 context.Context, i1 *dataexchange.ListDataSetRevisionsInput, i2 ...request.Option) (r0 *dataexchange.ListDataSetRevisionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetRevisionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.ListDataSetRevisionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetRevisionsWithContext(ctx context.Context, in *dataexchange.ListDataSetRevisionsInput, _ ...request.Option) (*dataexchange.ListDataSetRevisionsOutput, error) {

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

func (d *DataExchangeDouble) ListDataSets(i0 *dataexchange.ListDataSetsInput) (r0 *dataexchange.ListDataSetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSets", i0)
	r0, _ = returns[0].(*dataexchange.ListDataSetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) ListDataSetsPages(i0 *dataexchange.ListDataSetsInput, i1 func(*dataexchange.ListDataSetsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetsPages(in *dataexchange.ListDataSetsInput, pager func(*dataexchange.ListDataSetsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListDataSets", paginators, in, pager)
}

func (d *DataExchangeDouble) ListDataSetsPagesWithContext(i0 context.Context, i1 *dataexchange.ListDataSetsInput, i2 func(*dataexchange.ListDataSetsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetsPagesWithContext(ctx context.Context, in *dataexchange.ListDataSetsInput, pager func(*dataexchange.ListDataSetsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListDataSets", paginators, ctx, in, pager, options...)
}

func (d *DataExchangeDouble) ListDataSetsRequest(i0 *dataexchange.ListDataSetsInput) (r0 *request.Request, r1 *dataexchange.ListDataSetsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.ListDataSetsOutput)
	return
}

func (d *DataExchangeDouble) ListDataSetsWithContext(i0 context.Context, i1 *dataexchange.ListDataSetsInput, i2 ...request.Option) (r0 *dataexchange.ListDataSetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListDataSetsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.ListDataSetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeListDataSetsWithContext(ctx context.Context, in *dataexchange.ListDataSetsInput, _ ...request.Option) (*dataexchange.ListDataSetsOutput, error) {

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

func (d *DataExchangeDouble) ListJobs(i0 *dataexchange.ListJobsInput) (r0 *dataexchange.ListJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListJobs", i0)
	r0, _ = returns[0].(*dataexchange.ListJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) ListJobsPages(i0 *dataexchange.ListJobsInput, i1 func(*dataexchange.ListJobsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListJobsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListJobsPages(in *dataexchange.ListJobsInput, pager func(*dataexchange.ListJobsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListJobs", paginators, in, pager)
}

func (d *DataExchangeDouble) ListJobsPagesWithContext(i0 context.Context, i1 *dataexchange.ListJobsInput, i2 func(*dataexchange.ListJobsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListJobsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListJobsPagesWithContext(ctx context.Context, in *dataexchange.ListJobsInput, pager func(*dataexchange.ListJobsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListJobs", paginators, ctx, in, pager, options...)
}

func (d *DataExchangeDouble) ListJobsRequest(i0 *dataexchange.ListJobsInput) (r0 *request.Request, r1 *dataexchange.ListJobsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListJobsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.ListJobsOutput)
	return
}

func (d *DataExchangeDouble) ListJobsWithContext(i0 context.Context, i1 *dataexchange.ListJobsInput, i2 ...request.Option) (r0 *dataexchange.ListJobsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListJobsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.ListJobsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeListJobsWithContext(ctx context.Context, in *dataexchange.ListJobsInput, _ ...request.Option) (*dataexchange.ListJobsOutput, error) {

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

func (d *DataExchangeDouble) ListRevisionAssets(i0 *dataexchange.ListRevisionAssetsInput) (r0 *dataexchange.ListRevisionAssetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRevisionAssets", i0)
	r0, _ = returns[0].(*dataexchange.ListRevisionAssetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) ListRevisionAssetsPages(i0 *dataexchange.ListRevisionAssetsInput, i1 func(*dataexchange.ListRevisionAssetsOutput, bool) bool) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRevisionAssetsPages", i0, i1)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListRevisionAssetsPages(in *dataexchange.ListRevisionAssetsInput, pager func(*dataexchange.ListRevisionAssetsOutput, bool) (shouldContinue bool)) error {
	return d.Paginate("ListRevisionAssets", paginators, in, pager)
}

func (d *DataExchangeDouble) ListRevisionAssetsPagesWithContext(i0 context.Context, i1 *dataexchange.ListRevisionAssetsInput, i2 func(*dataexchange.ListRevisionAssetsOutput, bool) bool, i3 ...request.Option) (r0 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRevisionAssetsPagesWithContext", i0, i1, i2, i3)
	r0, _ = returns[0].(error)
	return
}

func (d *DataExchangeDouble) fakeListRevisionAssetsPagesWithContext(ctx context.Context, in *dataexchange.ListRevisionAssetsInput, pager func(*dataexchange.ListRevisionAssetsOutput, bool) (shouldContinue bool), options ...request.Option) error {
	return d.PaginateWithContext("ListRevisionAssets", paginators, ctx, in, pager, options...)
}

func (d *DataExchangeDouble) ListRevisionAssetsRequest(i0 *dataexchange.ListRevisionAssetsInput) (r0 *request.Request, r1 *dataexchange.ListRevisionAssetsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRevisionAssetsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.ListRevisionAssetsOutput)
	return
}

func (d *DataExchangeDouble) ListRevisionAssetsWithContext(i0 context.Context, i1 *dataexchange.ListRevisionAssetsInput, i2 ...request.Option) (r0 *dataexchange.ListRevisionAssetsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListRevisionAssetsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.ListRevisionAssetsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeListRevisionAssetsWithContext(ctx context.Context, in *dataexchange.ListRevisionAssetsInput, _ ...request.Option) (*dataexchange.ListRevisionAssetsOutput, error) {

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

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

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

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

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

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

func (d *DataExchangeDouble) StartJob(i0 *dataexchange.StartJobInput) (r0 *dataexchange.StartJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartJob", i0)
	r0, _ = returns[0].(*dataexchange.StartJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) StartJobRequest(i0 *dataexchange.StartJobInput) (r0 *request.Request, r1 *dataexchange.StartJobOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartJobRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.StartJobOutput)
	return
}

func (d *DataExchangeDouble) StartJobWithContext(i0 context.Context, i1 *dataexchange.StartJobInput, i2 ...request.Option) (r0 *dataexchange.StartJobOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("StartJobWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.StartJobOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeStartJobWithContext(ctx context.Context, in *dataexchange.StartJobInput, _ ...request.Option) (*dataexchange.StartJobOutput, error) {

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

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

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

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

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

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

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

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

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

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

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

func (d *DataExchangeDouble) UpdateAsset(i0 *dataexchange.UpdateAssetInput) (r0 *dataexchange.UpdateAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAsset", i0)
	r0, _ = returns[0].(*dataexchange.UpdateAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) UpdateAssetRequest(i0 *dataexchange.UpdateAssetInput) (r0 *request.Request, r1 *dataexchange.UpdateAssetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAssetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.UpdateAssetOutput)
	return
}

func (d *DataExchangeDouble) UpdateAssetWithContext(i0 context.Context, i1 *dataexchange.UpdateAssetInput, i2 ...request.Option) (r0 *dataexchange.UpdateAssetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateAssetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.UpdateAssetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeUpdateAssetWithContext(ctx context.Context, in *dataexchange.UpdateAssetInput, _ ...request.Option) (*dataexchange.UpdateAssetOutput, error) {

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

func (d *DataExchangeDouble) UpdateDataSet(i0 *dataexchange.UpdateDataSetInput) (r0 *dataexchange.UpdateDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDataSet", i0)
	r0, _ = returns[0].(*dataexchange.UpdateDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) UpdateDataSetRequest(i0 *dataexchange.UpdateDataSetInput) (r0 *request.Request, r1 *dataexchange.UpdateDataSetOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDataSetRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.UpdateDataSetOutput)
	return
}

func (d *DataExchangeDouble) UpdateDataSetWithContext(i0 context.Context, i1 *dataexchange.UpdateDataSetInput, i2 ...request.Option) (r0 *dataexchange.UpdateDataSetOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateDataSetWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.UpdateDataSetOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeUpdateDataSetWithContext(ctx context.Context, in *dataexchange.UpdateDataSetInput, _ ...request.Option) (*dataexchange.UpdateDataSetOutput, error) {

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

func (d *DataExchangeDouble) UpdateRevision(i0 *dataexchange.UpdateRevisionInput) (r0 *dataexchange.UpdateRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRevision", i0)
	r0, _ = returns[0].(*dataexchange.UpdateRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) UpdateRevisionRequest(i0 *dataexchange.UpdateRevisionInput) (r0 *request.Request, r1 *dataexchange.UpdateRevisionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRevisionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*dataexchange.UpdateRevisionOutput)
	return
}

func (d *DataExchangeDouble) UpdateRevisionWithContext(i0 context.Context, i1 *dataexchange.UpdateRevisionInput, i2 ...request.Option) (r0 *dataexchange.UpdateRevisionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateRevisionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*dataexchange.UpdateRevisionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *DataExchangeDouble) fakeUpdateRevisionWithContext(ctx context.Context, in *dataexchange.UpdateRevisionInput, _ ...request.Option) (*dataexchange.UpdateRevisionOutput, error) {

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