double.go

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

// Package shielddouble provides a TestDouble implementation of shieldiface.ShieldAPI
package shielddouble

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

// ShieldDouble is TestDouble for shieldiface.ShieldAPI
type ShieldDouble struct {
	shieldiface.ShieldAPI
	*awsdouble.AWSTestDouble
}

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

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

	result.AWSTestDouble = awsdouble.NewDouble(t, (*shieldiface.ShieldAPI)(nil), configurators...)
	return result
}

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

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

	case "AssociateDRTLogBucketWithContext":
		return m.Fake(d.fakeAssociateDRTLogBucketWithContext)

	case "AssociateDRTRoleWithContext":
		return m.Fake(d.fakeAssociateDRTRoleWithContext)

	case "CreateProtectionWithContext":
		return m.Fake(d.fakeCreateProtectionWithContext)

	case "CreateSubscriptionWithContext":
		return m.Fake(d.fakeCreateSubscriptionWithContext)

	case "DeleteProtectionWithContext":
		return m.Fake(d.fakeDeleteProtectionWithContext)

	case "DeleteSubscriptionWithContext":
		return m.Fake(d.fakeDeleteSubscriptionWithContext)

	case "DescribeAttackWithContext":
		return m.Fake(d.fakeDescribeAttackWithContext)

	case "DescribeDRTAccessWithContext":
		return m.Fake(d.fakeDescribeDRTAccessWithContext)

	case "DescribeEmergencyContactSettingsWithContext":
		return m.Fake(d.fakeDescribeEmergencyContactSettingsWithContext)

	case "DescribeProtectionWithContext":
		return m.Fake(d.fakeDescribeProtectionWithContext)

	case "DescribeSubscriptionWithContext":
		return m.Fake(d.fakeDescribeSubscriptionWithContext)

	case "DisassociateDRTLogBucketWithContext":
		return m.Fake(d.fakeDisassociateDRTLogBucketWithContext)

	case "DisassociateDRTRoleWithContext":
		return m.Fake(d.fakeDisassociateDRTRoleWithContext)

	case "GetSubscriptionStateWithContext":
		return m.Fake(d.fakeGetSubscriptionStateWithContext)

	case "ListAttacksWithContext":
		return m.Fake(d.fakeListAttacksWithContext)

	case "ListProtectionsWithContext":
		return m.Fake(d.fakeListProtectionsWithContext)

	case "UpdateEmergencyContactSettingsWithContext":
		return m.Fake(d.fakeUpdateEmergencyContactSettingsWithContext)

	case "UpdateSubscriptionWithContext":
		return m.Fake(d.fakeUpdateSubscriptionWithContext)

	default:
		return nil
	}
}

func (d *ShieldDouble) AssociateDRTLogBucket(i0 *shield.AssociateDRTLogBucketInput) (r0 *shield.AssociateDRTLogBucketOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTLogBucket", i0)
	r0, _ = returns[0].(*shield.AssociateDRTLogBucketOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) AssociateDRTLogBucketRequest(i0 *shield.AssociateDRTLogBucketInput) (r0 *request.Request, r1 *shield.AssociateDRTLogBucketOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTLogBucketRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.AssociateDRTLogBucketOutput)
	return
}

func (d *ShieldDouble) AssociateDRTLogBucketWithContext(i0 context.Context, i1 *shield.AssociateDRTLogBucketInput, i2 ...request.Option) (r0 *shield.AssociateDRTLogBucketOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTLogBucketWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.AssociateDRTLogBucketOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeAssociateDRTLogBucketWithContext(ctx context.Context, in *shield.AssociateDRTLogBucketInput, _ ...request.Option) (*shield.AssociateDRTLogBucketOutput, error) {

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

func (d *ShieldDouble) AssociateDRTRole(i0 *shield.AssociateDRTRoleInput) (r0 *shield.AssociateDRTRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTRole", i0)
	r0, _ = returns[0].(*shield.AssociateDRTRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) AssociateDRTRoleRequest(i0 *shield.AssociateDRTRoleInput) (r0 *request.Request, r1 *shield.AssociateDRTRoleOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTRoleRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.AssociateDRTRoleOutput)
	return
}

func (d *ShieldDouble) AssociateDRTRoleWithContext(i0 context.Context, i1 *shield.AssociateDRTRoleInput, i2 ...request.Option) (r0 *shield.AssociateDRTRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("AssociateDRTRoleWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.AssociateDRTRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeAssociateDRTRoleWithContext(ctx context.Context, in *shield.AssociateDRTRoleInput, _ ...request.Option) (*shield.AssociateDRTRoleOutput, error) {

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

func (d *ShieldDouble) CreateProtection(i0 *shield.CreateProtectionInput) (r0 *shield.CreateProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateProtection", i0)
	r0, _ = returns[0].(*shield.CreateProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) CreateProtectionRequest(i0 *shield.CreateProtectionInput) (r0 *request.Request, r1 *shield.CreateProtectionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateProtectionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.CreateProtectionOutput)
	return
}

func (d *ShieldDouble) CreateProtectionWithContext(i0 context.Context, i1 *shield.CreateProtectionInput, i2 ...request.Option) (r0 *shield.CreateProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateProtectionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.CreateProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeCreateProtectionWithContext(ctx context.Context, in *shield.CreateProtectionInput, _ ...request.Option) (*shield.CreateProtectionOutput, error) {

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

func (d *ShieldDouble) CreateSubscription(i0 *shield.CreateSubscriptionInput) (r0 *shield.CreateSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSubscription", i0)
	r0, _ = returns[0].(*shield.CreateSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) CreateSubscriptionRequest(i0 *shield.CreateSubscriptionInput) (r0 *request.Request, r1 *shield.CreateSubscriptionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSubscriptionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.CreateSubscriptionOutput)
	return
}

func (d *ShieldDouble) CreateSubscriptionWithContext(i0 context.Context, i1 *shield.CreateSubscriptionInput, i2 ...request.Option) (r0 *shield.CreateSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("CreateSubscriptionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.CreateSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeCreateSubscriptionWithContext(ctx context.Context, in *shield.CreateSubscriptionInput, _ ...request.Option) (*shield.CreateSubscriptionOutput, error) {

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

func (d *ShieldDouble) DeleteProtection(i0 *shield.DeleteProtectionInput) (r0 *shield.DeleteProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProtection", i0)
	r0, _ = returns[0].(*shield.DeleteProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DeleteProtectionRequest(i0 *shield.DeleteProtectionInput) (r0 *request.Request, r1 *shield.DeleteProtectionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProtectionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DeleteProtectionOutput)
	return
}

func (d *ShieldDouble) DeleteProtectionWithContext(i0 context.Context, i1 *shield.DeleteProtectionInput, i2 ...request.Option) (r0 *shield.DeleteProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteProtectionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DeleteProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDeleteProtectionWithContext(ctx context.Context, in *shield.DeleteProtectionInput, _ ...request.Option) (*shield.DeleteProtectionOutput, error) {

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

func (d *ShieldDouble) DeleteSubscription(i0 *shield.DeleteSubscriptionInput) (r0 *shield.DeleteSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSubscription", i0)
	r0, _ = returns[0].(*shield.DeleteSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DeleteSubscriptionRequest(i0 *shield.DeleteSubscriptionInput) (r0 *request.Request, r1 *shield.DeleteSubscriptionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSubscriptionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DeleteSubscriptionOutput)
	return
}

func (d *ShieldDouble) DeleteSubscriptionWithContext(i0 context.Context, i1 *shield.DeleteSubscriptionInput, i2 ...request.Option) (r0 *shield.DeleteSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DeleteSubscriptionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DeleteSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDeleteSubscriptionWithContext(ctx context.Context, in *shield.DeleteSubscriptionInput, _ ...request.Option) (*shield.DeleteSubscriptionOutput, error) {

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

func (d *ShieldDouble) DescribeAttack(i0 *shield.DescribeAttackInput) (r0 *shield.DescribeAttackOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAttack", i0)
	r0, _ = returns[0].(*shield.DescribeAttackOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DescribeAttackRequest(i0 *shield.DescribeAttackInput) (r0 *request.Request, r1 *shield.DescribeAttackOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAttackRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DescribeAttackOutput)
	return
}

func (d *ShieldDouble) DescribeAttackWithContext(i0 context.Context, i1 *shield.DescribeAttackInput, i2 ...request.Option) (r0 *shield.DescribeAttackOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeAttackWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DescribeAttackOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDescribeAttackWithContext(ctx context.Context, in *shield.DescribeAttackInput, _ ...request.Option) (*shield.DescribeAttackOutput, error) {

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

func (d *ShieldDouble) DescribeDRTAccess(i0 *shield.DescribeDRTAccessInput) (r0 *shield.DescribeDRTAccessOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDRTAccess", i0)
	r0, _ = returns[0].(*shield.DescribeDRTAccessOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DescribeDRTAccessRequest(i0 *shield.DescribeDRTAccessInput) (r0 *request.Request, r1 *shield.DescribeDRTAccessOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDRTAccessRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DescribeDRTAccessOutput)
	return
}

func (d *ShieldDouble) DescribeDRTAccessWithContext(i0 context.Context, i1 *shield.DescribeDRTAccessInput, i2 ...request.Option) (r0 *shield.DescribeDRTAccessOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeDRTAccessWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DescribeDRTAccessOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDescribeDRTAccessWithContext(ctx context.Context, in *shield.DescribeDRTAccessInput, _ ...request.Option) (*shield.DescribeDRTAccessOutput, error) {

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

func (d *ShieldDouble) DescribeEmergencyContactSettings(i0 *shield.DescribeEmergencyContactSettingsInput) (r0 *shield.DescribeEmergencyContactSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeEmergencyContactSettings", i0)
	r0, _ = returns[0].(*shield.DescribeEmergencyContactSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DescribeEmergencyContactSettingsRequest(i0 *shield.DescribeEmergencyContactSettingsInput) (r0 *request.Request, r1 *shield.DescribeEmergencyContactSettingsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeEmergencyContactSettingsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DescribeEmergencyContactSettingsOutput)
	return
}

func (d *ShieldDouble) DescribeEmergencyContactSettingsWithContext(i0 context.Context, i1 *shield.DescribeEmergencyContactSettingsInput, i2 ...request.Option) (r0 *shield.DescribeEmergencyContactSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeEmergencyContactSettingsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DescribeEmergencyContactSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDescribeEmergencyContactSettingsWithContext(ctx context.Context, in *shield.DescribeEmergencyContactSettingsInput, _ ...request.Option) (*shield.DescribeEmergencyContactSettingsOutput, error) {

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

func (d *ShieldDouble) DescribeProtection(i0 *shield.DescribeProtectionInput) (r0 *shield.DescribeProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeProtection", i0)
	r0, _ = returns[0].(*shield.DescribeProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DescribeProtectionRequest(i0 *shield.DescribeProtectionInput) (r0 *request.Request, r1 *shield.DescribeProtectionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeProtectionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DescribeProtectionOutput)
	return
}

func (d *ShieldDouble) DescribeProtectionWithContext(i0 context.Context, i1 *shield.DescribeProtectionInput, i2 ...request.Option) (r0 *shield.DescribeProtectionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeProtectionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DescribeProtectionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDescribeProtectionWithContext(ctx context.Context, in *shield.DescribeProtectionInput, _ ...request.Option) (*shield.DescribeProtectionOutput, error) {

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

func (d *ShieldDouble) DescribeSubscription(i0 *shield.DescribeSubscriptionInput) (r0 *shield.DescribeSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSubscription", i0)
	r0, _ = returns[0].(*shield.DescribeSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DescribeSubscriptionRequest(i0 *shield.DescribeSubscriptionInput) (r0 *request.Request, r1 *shield.DescribeSubscriptionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSubscriptionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DescribeSubscriptionOutput)
	return
}

func (d *ShieldDouble) DescribeSubscriptionWithContext(i0 context.Context, i1 *shield.DescribeSubscriptionInput, i2 ...request.Option) (r0 *shield.DescribeSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DescribeSubscriptionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DescribeSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDescribeSubscriptionWithContext(ctx context.Context, in *shield.DescribeSubscriptionInput, _ ...request.Option) (*shield.DescribeSubscriptionOutput, error) {

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

func (d *ShieldDouble) DisassociateDRTLogBucket(i0 *shield.DisassociateDRTLogBucketInput) (r0 *shield.DisassociateDRTLogBucketOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTLogBucket", i0)
	r0, _ = returns[0].(*shield.DisassociateDRTLogBucketOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DisassociateDRTLogBucketRequest(i0 *shield.DisassociateDRTLogBucketInput) (r0 *request.Request, r1 *shield.DisassociateDRTLogBucketOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTLogBucketRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DisassociateDRTLogBucketOutput)
	return
}

func (d *ShieldDouble) DisassociateDRTLogBucketWithContext(i0 context.Context, i1 *shield.DisassociateDRTLogBucketInput, i2 ...request.Option) (r0 *shield.DisassociateDRTLogBucketOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTLogBucketWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DisassociateDRTLogBucketOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDisassociateDRTLogBucketWithContext(ctx context.Context, in *shield.DisassociateDRTLogBucketInput, _ ...request.Option) (*shield.DisassociateDRTLogBucketOutput, error) {

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

func (d *ShieldDouble) DisassociateDRTRole(i0 *shield.DisassociateDRTRoleInput) (r0 *shield.DisassociateDRTRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTRole", i0)
	r0, _ = returns[0].(*shield.DisassociateDRTRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) DisassociateDRTRoleRequest(i0 *shield.DisassociateDRTRoleInput) (r0 *request.Request, r1 *shield.DisassociateDRTRoleOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTRoleRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.DisassociateDRTRoleOutput)
	return
}

func (d *ShieldDouble) DisassociateDRTRoleWithContext(i0 context.Context, i1 *shield.DisassociateDRTRoleInput, i2 ...request.Option) (r0 *shield.DisassociateDRTRoleOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("DisassociateDRTRoleWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.DisassociateDRTRoleOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeDisassociateDRTRoleWithContext(ctx context.Context, in *shield.DisassociateDRTRoleInput, _ ...request.Option) (*shield.DisassociateDRTRoleOutput, error) {

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

func (d *ShieldDouble) GetSubscriptionState(i0 *shield.GetSubscriptionStateInput) (r0 *shield.GetSubscriptionStateOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetSubscriptionState", i0)
	r0, _ = returns[0].(*shield.GetSubscriptionStateOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) GetSubscriptionStateRequest(i0 *shield.GetSubscriptionStateInput) (r0 *request.Request, r1 *shield.GetSubscriptionStateOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetSubscriptionStateRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.GetSubscriptionStateOutput)
	return
}

func (d *ShieldDouble) GetSubscriptionStateWithContext(i0 context.Context, i1 *shield.GetSubscriptionStateInput, i2 ...request.Option) (r0 *shield.GetSubscriptionStateOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("GetSubscriptionStateWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.GetSubscriptionStateOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeGetSubscriptionStateWithContext(ctx context.Context, in *shield.GetSubscriptionStateInput, _ ...request.Option) (*shield.GetSubscriptionStateOutput, error) {

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

func (d *ShieldDouble) ListAttacks(i0 *shield.ListAttacksInput) (r0 *shield.ListAttacksOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAttacks", i0)
	r0, _ = returns[0].(*shield.ListAttacksOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) ListAttacksRequest(i0 *shield.ListAttacksInput) (r0 *request.Request, r1 *shield.ListAttacksOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAttacksRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.ListAttacksOutput)
	return
}

func (d *ShieldDouble) ListAttacksWithContext(i0 context.Context, i1 *shield.ListAttacksInput, i2 ...request.Option) (r0 *shield.ListAttacksOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListAttacksWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.ListAttacksOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeListAttacksWithContext(ctx context.Context, in *shield.ListAttacksInput, _ ...request.Option) (*shield.ListAttacksOutput, error) {

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

func (d *ShieldDouble) ListProtections(i0 *shield.ListProtectionsInput) (r0 *shield.ListProtectionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProtections", i0)
	r0, _ = returns[0].(*shield.ListProtectionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) ListProtectionsRequest(i0 *shield.ListProtectionsInput) (r0 *request.Request, r1 *shield.ListProtectionsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProtectionsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.ListProtectionsOutput)
	return
}

func (d *ShieldDouble) ListProtectionsWithContext(i0 context.Context, i1 *shield.ListProtectionsInput, i2 ...request.Option) (r0 *shield.ListProtectionsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("ListProtectionsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.ListProtectionsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeListProtectionsWithContext(ctx context.Context, in *shield.ListProtectionsInput, _ ...request.Option) (*shield.ListProtectionsOutput, error) {

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

func (d *ShieldDouble) UpdateEmergencyContactSettings(i0 *shield.UpdateEmergencyContactSettingsInput) (r0 *shield.UpdateEmergencyContactSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEmergencyContactSettings", i0)
	r0, _ = returns[0].(*shield.UpdateEmergencyContactSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) UpdateEmergencyContactSettingsRequest(i0 *shield.UpdateEmergencyContactSettingsInput) (r0 *request.Request, r1 *shield.UpdateEmergencyContactSettingsOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEmergencyContactSettingsRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.UpdateEmergencyContactSettingsOutput)
	return
}

func (d *ShieldDouble) UpdateEmergencyContactSettingsWithContext(i0 context.Context, i1 *shield.UpdateEmergencyContactSettingsInput, i2 ...request.Option) (r0 *shield.UpdateEmergencyContactSettingsOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateEmergencyContactSettingsWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.UpdateEmergencyContactSettingsOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeUpdateEmergencyContactSettingsWithContext(ctx context.Context, in *shield.UpdateEmergencyContactSettingsInput, _ ...request.Option) (*shield.UpdateEmergencyContactSettingsOutput, error) {

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

func (d *ShieldDouble) UpdateSubscription(i0 *shield.UpdateSubscriptionInput) (r0 *shield.UpdateSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSubscription", i0)
	r0, _ = returns[0].(*shield.UpdateSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) UpdateSubscriptionRequest(i0 *shield.UpdateSubscriptionInput) (r0 *request.Request, r1 *shield.UpdateSubscriptionOutput) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSubscriptionRequest", i0)
	r0, _ = returns[0].(*request.Request)
	r1, _ = returns[1].(*shield.UpdateSubscriptionOutput)
	return
}

func (d *ShieldDouble) UpdateSubscriptionWithContext(i0 context.Context, i1 *shield.UpdateSubscriptionInput, i2 ...request.Option) (r0 *shield.UpdateSubscriptionOutput, r1 error) {
	d.TestDouble.T().Helper()
	returns := d.TestDouble.Invoke("UpdateSubscriptionWithContext", i0, i1, i2)
	r0, _ = returns[0].(*shield.UpdateSubscriptionOutput)
	r1, _ = returns[1].(error)
	return
}

func (d *ShieldDouble) fakeUpdateSubscriptionWithContext(ctx context.Context, in *shield.UpdateSubscriptionInput, _ ...request.Option) (*shield.UpdateSubscriptionOutput, error) {

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