versitygw/s3api/controllers/backend_moq_test.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package controllers

import (
	"context"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/versity/versitygw/backend"
	"github.com/versity/versitygw/s3response"
	"io"
	"sync"
)

// Ensure, that BackendMock does implement backend.Backend.
// If this is not the case, regenerate this file with moq.
var _ backend.Backend = &BackendMock{}

// BackendMock is a mock implementation of backend.Backend.
//
//	func TestSomethingThatUsesBackend(t *testing.T) {
//
//		// make and configure a mocked backend.Backend
//		mockedBackend := &BackendMock{
//			AbortMultipartUploadFunc: func(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error {
//				panic("mock out the AbortMultipartUpload method")
//			},
//			CompleteMultipartUploadFunc: func(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
//				panic("mock out the CompleteMultipartUpload method")
//			},
//			CopyObjectFunc: func(contextMoqParam context.Context, copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
//				panic("mock out the CopyObject method")
//			},
//			CreateBucketFunc: func(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput) error {
//				panic("mock out the CreateBucket method")
//			},
//			CreateMultipartUploadFunc: func(contextMoqParam context.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
//				panic("mock out the CreateMultipartUpload method")
//			},
//			DeleteBucketFunc: func(contextMoqParam context.Context, deleteBucketInput *s3.DeleteBucketInput) error {
//				panic("mock out the DeleteBucket method")
//			},
//			DeleteObjectFunc: func(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) error {
//				panic("mock out the DeleteObject method")
//			},
//			DeleteObjectsFunc: func(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteObjectsResult, error) {
//				panic("mock out the DeleteObjects method")
//			},
//			GetBucketAclFunc: func(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error) {
//				panic("mock out the GetBucketAcl method")
//			},
//			GetObjectFunc: func(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput, writer io.Writer) (*s3.GetObjectOutput, error) {
//				panic("mock out the GetObject method")
//			},
//			GetObjectAclFunc: func(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
//				panic("mock out the GetObjectAcl method")
//			},
//			GetObjectAttributesFunc: func(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
//				panic("mock out the GetObjectAttributes method")
//			},
//			GetTagsFunc: func(contextMoqParam context.Context, bucket string, object string) (map[string]string, error) {
//				panic("mock out the GetTags method")
//			},
//			HeadBucketFunc: func(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
//				panic("mock out the HeadBucket method")
//			},
//			HeadObjectFunc: func(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
//				panic("mock out the HeadObject method")
//			},
//			ListBucketsFunc: func(contextMoqParam context.Context, owner string, isRoot bool) (s3response.ListAllMyBucketsResult, error) {
//				panic("mock out the ListBuckets method")
//			},
//			ListMultipartUploadsFunc: func(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
//				panic("mock out the ListMultipartUploads method")
//			},
//			ListObjectsFunc: func(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
//				panic("mock out the ListObjects method")
//			},
//			ListObjectsV2Func: func(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
//				panic("mock out the ListObjectsV2 method")
//			},
//			ListPartsFunc: func(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error) {
//				panic("mock out the ListParts method")
//			},
//			PutBucketAclFunc: func(contextMoqParam context.Context, bucket string, data []byte) error {
//				panic("mock out the PutBucketAcl method")
//			},
//			PutObjectFunc: func(contextMoqParam context.Context, putObjectInput *s3.PutObjectInput) (string, error) {
//				panic("mock out the PutObject method")
//			},
//			PutObjectAclFunc: func(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error {
//				panic("mock out the PutObjectAcl method")
//			},
//			RemoveTagsFunc: func(contextMoqParam context.Context, bucket string, object string) error {
//				panic("mock out the RemoveTags method")
//			},
//			RestoreObjectFunc: func(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error {
//				panic("mock out the RestoreObject method")
//			},
//			SelectObjectContentFunc: func(contextMoqParam context.Context, selectObjectContentInput *s3.SelectObjectContentInput) (s3response.SelectObjectContentResult, error) {
//				panic("mock out the SelectObjectContent method")
//			},
//			SetTagsFunc: func(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
//				panic("mock out the SetTags method")
//			},
//			ShutdownFunc: func()  {
//				panic("mock out the Shutdown method")
//			},
//			StringFunc: func() string {
//				panic("mock out the String method")
//			},
//			UploadPartFunc: func(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (string, error) {
//				panic("mock out the UploadPart method")
//			},
//			UploadPartCopyFunc: func(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyObjectResult, error) {
//				panic("mock out the UploadPartCopy method")
//			},
//		}
//
//		// use mockedBackend in code that requires backend.Backend
//		// and then make assertions.
//
//	}
type BackendMock struct {
	// AbortMultipartUploadFunc mocks the AbortMultipartUpload method.
	AbortMultipartUploadFunc func(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error

	// CompleteMultipartUploadFunc mocks the CompleteMultipartUpload method.
	CompleteMultipartUploadFunc func(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)

	// CopyObjectFunc mocks the CopyObject method.
	CopyObjectFunc func(contextMoqParam context.Context, copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error)

	// CreateBucketFunc mocks the CreateBucket method.
	CreateBucketFunc func(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput) error

	// CreateMultipartUploadFunc mocks the CreateMultipartUpload method.
	CreateMultipartUploadFunc func(contextMoqParam context.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)

	// DeleteBucketFunc mocks the DeleteBucket method.
	DeleteBucketFunc func(contextMoqParam context.Context, deleteBucketInput *s3.DeleteBucketInput) error

	// DeleteObjectFunc mocks the DeleteObject method.
	DeleteObjectFunc func(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) error

	// DeleteObjectsFunc mocks the DeleteObjects method.
	DeleteObjectsFunc func(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteObjectsResult, error)

	// GetBucketAclFunc mocks the GetBucketAcl method.
	GetBucketAclFunc func(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error)

	// GetObjectFunc mocks the GetObject method.
	GetObjectFunc func(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput, writer io.Writer) (*s3.GetObjectOutput, error)

	// GetObjectAclFunc mocks the GetObjectAcl method.
	GetObjectAclFunc func(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)

	// GetObjectAttributesFunc mocks the GetObjectAttributes method.
	GetObjectAttributesFunc func(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)

	// GetTagsFunc mocks the GetTags method.
	GetTagsFunc func(contextMoqParam context.Context, bucket string, object string) (map[string]string, error)

	// HeadBucketFunc mocks the HeadBucket method.
	HeadBucketFunc func(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error)

	// HeadObjectFunc mocks the HeadObject method.
	HeadObjectFunc func(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error)

	// ListBucketsFunc mocks the ListBuckets method.
	ListBucketsFunc func(contextMoqParam context.Context, owner string, isRoot bool) (s3response.ListAllMyBucketsResult, error)

	// ListMultipartUploadsFunc mocks the ListMultipartUploads method.
	ListMultipartUploadsFunc func(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error)

	// ListObjectsFunc mocks the ListObjects method.
	ListObjectsFunc func(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error)

	// ListObjectsV2Func mocks the ListObjectsV2 method.
	ListObjectsV2Func func(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)

	// ListPartsFunc mocks the ListParts method.
	ListPartsFunc func(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error)

	// PutBucketAclFunc mocks the PutBucketAcl method.
	PutBucketAclFunc func(contextMoqParam context.Context, bucket string, data []byte) error

	// PutObjectFunc mocks the PutObject method.
	PutObjectFunc func(contextMoqParam context.Context, putObjectInput *s3.PutObjectInput) (string, error)

	// PutObjectAclFunc mocks the PutObjectAcl method.
	PutObjectAclFunc func(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error

	// RemoveTagsFunc mocks the RemoveTags method.
	RemoveTagsFunc func(contextMoqParam context.Context, bucket string, object string) error

	// RestoreObjectFunc mocks the RestoreObject method.
	RestoreObjectFunc func(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error

	// SelectObjectContentFunc mocks the SelectObjectContent method.
	SelectObjectContentFunc func(contextMoqParam context.Context, selectObjectContentInput *s3.SelectObjectContentInput) (s3response.SelectObjectContentResult, error)

	// SetTagsFunc mocks the SetTags method.
	SetTagsFunc func(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error

	// ShutdownFunc mocks the Shutdown method.
	ShutdownFunc func()

	// StringFunc mocks the String method.
	StringFunc func() string

	// UploadPartFunc mocks the UploadPart method.
	UploadPartFunc func(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (string, error)

	// UploadPartCopyFunc mocks the UploadPartCopy method.
	UploadPartCopyFunc func(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyObjectResult, error)

	// calls tracks calls to the methods.
	calls struct {
		// AbortMultipartUpload holds details about calls to the AbortMultipartUpload method.
		AbortMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// AbortMultipartUploadInput is the abortMultipartUploadInput argument value.
			AbortMultipartUploadInput *s3.AbortMultipartUploadInput
		}
		// CompleteMultipartUpload holds details about calls to the CompleteMultipartUpload method.
		CompleteMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CompleteMultipartUploadInput is the completeMultipartUploadInput argument value.
			CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
		}
		// CopyObject holds details about calls to the CopyObject method.
		CopyObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CopyObjectInput is the copyObjectInput argument value.
			CopyObjectInput *s3.CopyObjectInput
		}
		// CreateBucket holds details about calls to the CreateBucket method.
		CreateBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CreateBucketInput is the createBucketInput argument value.
			CreateBucketInput *s3.CreateBucketInput
		}
		// CreateMultipartUpload holds details about calls to the CreateMultipartUpload method.
		CreateMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CreateMultipartUploadInput is the createMultipartUploadInput argument value.
			CreateMultipartUploadInput *s3.CreateMultipartUploadInput
		}
		// DeleteBucket holds details about calls to the DeleteBucket method.
		DeleteBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// DeleteBucketInput is the deleteBucketInput argument value.
			DeleteBucketInput *s3.DeleteBucketInput
		}
		// DeleteObject holds details about calls to the DeleteObject method.
		DeleteObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// DeleteObjectInput is the deleteObjectInput argument value.
			DeleteObjectInput *s3.DeleteObjectInput
		}
		// DeleteObjects holds details about calls to the DeleteObjects method.
		DeleteObjects []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// DeleteObjectsInput is the deleteObjectsInput argument value.
			DeleteObjectsInput *s3.DeleteObjectsInput
		}
		// GetBucketAcl holds details about calls to the GetBucketAcl method.
		GetBucketAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetBucketAclInput is the getBucketAclInput argument value.
			GetBucketAclInput *s3.GetBucketAclInput
		}
		// GetObject holds details about calls to the GetObject method.
		GetObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectInput is the getObjectInput argument value.
			GetObjectInput *s3.GetObjectInput
			// Writer is the writer argument value.
			Writer io.Writer
		}
		// GetObjectAcl holds details about calls to the GetObjectAcl method.
		GetObjectAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectAclInput is the getObjectAclInput argument value.
			GetObjectAclInput *s3.GetObjectAclInput
		}
		// GetObjectAttributes holds details about calls to the GetObjectAttributes method.
		GetObjectAttributes []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectAttributesInput is the getObjectAttributesInput argument value.
			GetObjectAttributesInput *s3.GetObjectAttributesInput
		}
		// GetTags holds details about calls to the GetTags method.
		GetTags []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
		}
		// HeadBucket holds details about calls to the HeadBucket method.
		HeadBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// HeadBucketInput is the headBucketInput argument value.
			HeadBucketInput *s3.HeadBucketInput
		}
		// HeadObject holds details about calls to the HeadObject method.
		HeadObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// HeadObjectInput is the headObjectInput argument value.
			HeadObjectInput *s3.HeadObjectInput
		}
		// ListBuckets holds details about calls to the ListBuckets method.
		ListBuckets []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Owner is the owner argument value.
			Owner string
			// IsRoot is the isRoot argument value.
			IsRoot bool
		}
		// ListMultipartUploads holds details about calls to the ListMultipartUploads method.
		ListMultipartUploads []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListMultipartUploadsInput is the listMultipartUploadsInput argument value.
			ListMultipartUploadsInput *s3.ListMultipartUploadsInput
		}
		// ListObjects holds details about calls to the ListObjects method.
		ListObjects []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectsInput is the listObjectsInput argument value.
			ListObjectsInput *s3.ListObjectsInput
		}
		// ListObjectsV2 holds details about calls to the ListObjectsV2 method.
		ListObjectsV2 []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectsV2Input is the listObjectsV2Input argument value.
			ListObjectsV2Input *s3.ListObjectsV2Input
		}
		// ListParts holds details about calls to the ListParts method.
		ListParts []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListPartsInput is the listPartsInput argument value.
			ListPartsInput *s3.ListPartsInput
		}
		// PutBucketAcl holds details about calls to the PutBucketAcl method.
		PutBucketAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Data is the data argument value.
			Data []byte
		}
		// PutObject holds details about calls to the PutObject method.
		PutObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// PutObjectInput is the putObjectInput argument value.
			PutObjectInput *s3.PutObjectInput
		}
		// PutObjectAcl holds details about calls to the PutObjectAcl method.
		PutObjectAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// PutObjectAclInput is the putObjectAclInput argument value.
			PutObjectAclInput *s3.PutObjectAclInput
		}
		// RemoveTags holds details about calls to the RemoveTags method.
		RemoveTags []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
		}
		// RestoreObject holds details about calls to the RestoreObject method.
		RestoreObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// RestoreObjectInput is the restoreObjectInput argument value.
			RestoreObjectInput *s3.RestoreObjectInput
		}
		// SelectObjectContent holds details about calls to the SelectObjectContent method.
		SelectObjectContent []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// SelectObjectContentInput is the selectObjectContentInput argument value.
			SelectObjectContentInput *s3.SelectObjectContentInput
		}
		// SetTags holds details about calls to the SetTags method.
		SetTags []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// Tags is the tags argument value.
			Tags map[string]string
		}
		// Shutdown holds details about calls to the Shutdown method.
		Shutdown []struct {
		}
		// String holds details about calls to the String method.
		String []struct {
		}
		// UploadPart holds details about calls to the UploadPart method.
		UploadPart []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// UploadPartInput is the uploadPartInput argument value.
			UploadPartInput *s3.UploadPartInput
		}
		// UploadPartCopy holds details about calls to the UploadPartCopy method.
		UploadPartCopy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// UploadPartCopyInput is the uploadPartCopyInput argument value.
			UploadPartCopyInput *s3.UploadPartCopyInput
		}
	}
	lockAbortMultipartUpload    sync.RWMutex
	lockCompleteMultipartUpload sync.RWMutex
	lockCopyObject              sync.RWMutex
	lockCreateBucket            sync.RWMutex
	lockCreateMultipartUpload   sync.RWMutex
	lockDeleteBucket            sync.RWMutex
	lockDeleteObject            sync.RWMutex
	lockDeleteObjects           sync.RWMutex
	lockGetBucketAcl            sync.RWMutex
	lockGetObject               sync.RWMutex
	lockGetObjectAcl            sync.RWMutex
	lockGetObjectAttributes     sync.RWMutex
	lockGetTags                 sync.RWMutex
	lockHeadBucket              sync.RWMutex
	lockHeadObject              sync.RWMutex
	lockListBuckets             sync.RWMutex
	lockListMultipartUploads    sync.RWMutex
	lockListObjects             sync.RWMutex
	lockListObjectsV2           sync.RWMutex
	lockListParts               sync.RWMutex
	lockPutBucketAcl            sync.RWMutex
	lockPutObject               sync.RWMutex
	lockPutObjectAcl            sync.RWMutex
	lockRemoveTags              sync.RWMutex
	lockRestoreObject           sync.RWMutex
	lockSelectObjectContent     sync.RWMutex
	lockSetTags                 sync.RWMutex
	lockShutdown                sync.RWMutex
	lockString                  sync.RWMutex
	lockUploadPart              sync.RWMutex
	lockUploadPartCopy          sync.RWMutex
}

// AbortMultipartUpload calls AbortMultipartUploadFunc.
func (mock *BackendMock) AbortMultipartUpload(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error {
	if mock.AbortMultipartUploadFunc == nil {
		panic("BackendMock.AbortMultipartUploadFunc: method is nil but Backend.AbortMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam           context.Context
		AbortMultipartUploadInput *s3.AbortMultipartUploadInput
	}{
		ContextMoqParam:           contextMoqParam,
		AbortMultipartUploadInput: abortMultipartUploadInput,
	}
	mock.lockAbortMultipartUpload.Lock()
	mock.calls.AbortMultipartUpload = append(mock.calls.AbortMultipartUpload, callInfo)
	mock.lockAbortMultipartUpload.Unlock()
	return mock.AbortMultipartUploadFunc(contextMoqParam, abortMultipartUploadInput)
}

// AbortMultipartUploadCalls gets all the calls that were made to AbortMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.AbortMultipartUploadCalls())
func (mock *BackendMock) AbortMultipartUploadCalls() []struct {
	ContextMoqParam           context.Context
	AbortMultipartUploadInput *s3.AbortMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam           context.Context
		AbortMultipartUploadInput *s3.AbortMultipartUploadInput
	}
	mock.lockAbortMultipartUpload.RLock()
	calls = mock.calls.AbortMultipartUpload
	mock.lockAbortMultipartUpload.RUnlock()
	return calls
}

// CompleteMultipartUpload calls CompleteMultipartUploadFunc.
func (mock *BackendMock) CompleteMultipartUpload(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
	if mock.CompleteMultipartUploadFunc == nil {
		panic("BackendMock.CompleteMultipartUploadFunc: method is nil but Backend.CompleteMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam              context.Context
		CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
	}{
		ContextMoqParam:              contextMoqParam,
		CompleteMultipartUploadInput: completeMultipartUploadInput,
	}
	mock.lockCompleteMultipartUpload.Lock()
	mock.calls.CompleteMultipartUpload = append(mock.calls.CompleteMultipartUpload, callInfo)
	mock.lockCompleteMultipartUpload.Unlock()
	return mock.CompleteMultipartUploadFunc(contextMoqParam, completeMultipartUploadInput)
}

// CompleteMultipartUploadCalls gets all the calls that were made to CompleteMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.CompleteMultipartUploadCalls())
func (mock *BackendMock) CompleteMultipartUploadCalls() []struct {
	ContextMoqParam              context.Context
	CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam              context.Context
		CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
	}
	mock.lockCompleteMultipartUpload.RLock()
	calls = mock.calls.CompleteMultipartUpload
	mock.lockCompleteMultipartUpload.RUnlock()
	return calls
}

// CopyObject calls CopyObjectFunc.
func (mock *BackendMock) CopyObject(contextMoqParam context.Context, copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
	if mock.CopyObjectFunc == nil {
		panic("BackendMock.CopyObjectFunc: method is nil but Backend.CopyObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		CopyObjectInput *s3.CopyObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		CopyObjectInput: copyObjectInput,
	}
	mock.lockCopyObject.Lock()
	mock.calls.CopyObject = append(mock.calls.CopyObject, callInfo)
	mock.lockCopyObject.Unlock()
	return mock.CopyObjectFunc(contextMoqParam, copyObjectInput)
}

// CopyObjectCalls gets all the calls that were made to CopyObject.
// Check the length with:
//
//	len(mockedBackend.CopyObjectCalls())
func (mock *BackendMock) CopyObjectCalls() []struct {
	ContextMoqParam context.Context
	CopyObjectInput *s3.CopyObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		CopyObjectInput *s3.CopyObjectInput
	}
	mock.lockCopyObject.RLock()
	calls = mock.calls.CopyObject
	mock.lockCopyObject.RUnlock()
	return calls
}

// CreateBucket calls CreateBucketFunc.
func (mock *BackendMock) CreateBucket(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput) error {
	if mock.CreateBucketFunc == nil {
		panic("BackendMock.CreateBucketFunc: method is nil but Backend.CreateBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		CreateBucketInput *s3.CreateBucketInput
	}{
		ContextMoqParam:   contextMoqParam,
		CreateBucketInput: createBucketInput,
	}
	mock.lockCreateBucket.Lock()
	mock.calls.CreateBucket = append(mock.calls.CreateBucket, callInfo)
	mock.lockCreateBucket.Unlock()
	return mock.CreateBucketFunc(contextMoqParam, createBucketInput)
}

// CreateBucketCalls gets all the calls that were made to CreateBucket.
// Check the length with:
//
//	len(mockedBackend.CreateBucketCalls())
func (mock *BackendMock) CreateBucketCalls() []struct {
	ContextMoqParam   context.Context
	CreateBucketInput *s3.CreateBucketInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		CreateBucketInput *s3.CreateBucketInput
	}
	mock.lockCreateBucket.RLock()
	calls = mock.calls.CreateBucket
	mock.lockCreateBucket.RUnlock()
	return calls
}

// CreateMultipartUpload calls CreateMultipartUploadFunc.
func (mock *BackendMock) CreateMultipartUpload(contextMoqParam context.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
	if mock.CreateMultipartUploadFunc == nil {
		panic("BackendMock.CreateMultipartUploadFunc: method is nil but Backend.CreateMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam            context.Context
		CreateMultipartUploadInput *s3.CreateMultipartUploadInput
	}{
		ContextMoqParam:            contextMoqParam,
		CreateMultipartUploadInput: createMultipartUploadInput,
	}
	mock.lockCreateMultipartUpload.Lock()
	mock.calls.CreateMultipartUpload = append(mock.calls.CreateMultipartUpload, callInfo)
	mock.lockCreateMultipartUpload.Unlock()
	return mock.CreateMultipartUploadFunc(contextMoqParam, createMultipartUploadInput)
}

// CreateMultipartUploadCalls gets all the calls that were made to CreateMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.CreateMultipartUploadCalls())
func (mock *BackendMock) CreateMultipartUploadCalls() []struct {
	ContextMoqParam            context.Context
	CreateMultipartUploadInput *s3.CreateMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam            context.Context
		CreateMultipartUploadInput *s3.CreateMultipartUploadInput
	}
	mock.lockCreateMultipartUpload.RLock()
	calls = mock.calls.CreateMultipartUpload
	mock.lockCreateMultipartUpload.RUnlock()
	return calls
}

// DeleteBucket calls DeleteBucketFunc.
func (mock *BackendMock) DeleteBucket(contextMoqParam context.Context, deleteBucketInput *s3.DeleteBucketInput) error {
	if mock.DeleteBucketFunc == nil {
		panic("BackendMock.DeleteBucketFunc: method is nil but Backend.DeleteBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		DeleteBucketInput *s3.DeleteBucketInput
	}{
		ContextMoqParam:   contextMoqParam,
		DeleteBucketInput: deleteBucketInput,
	}
	mock.lockDeleteBucket.Lock()
	mock.calls.DeleteBucket = append(mock.calls.DeleteBucket, callInfo)
	mock.lockDeleteBucket.Unlock()
	return mock.DeleteBucketFunc(contextMoqParam, deleteBucketInput)
}

// DeleteBucketCalls gets all the calls that were made to DeleteBucket.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketCalls())
func (mock *BackendMock) DeleteBucketCalls() []struct {
	ContextMoqParam   context.Context
	DeleteBucketInput *s3.DeleteBucketInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		DeleteBucketInput *s3.DeleteBucketInput
	}
	mock.lockDeleteBucket.RLock()
	calls = mock.calls.DeleteBucket
	mock.lockDeleteBucket.RUnlock()
	return calls
}

// DeleteObject calls DeleteObjectFunc.
func (mock *BackendMock) DeleteObject(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) error {
	if mock.DeleteObjectFunc == nil {
		panic("BackendMock.DeleteObjectFunc: method is nil but Backend.DeleteObject was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		DeleteObjectInput *s3.DeleteObjectInput
	}{
		ContextMoqParam:   contextMoqParam,
		DeleteObjectInput: deleteObjectInput,
	}
	mock.lockDeleteObject.Lock()
	mock.calls.DeleteObject = append(mock.calls.DeleteObject, callInfo)
	mock.lockDeleteObject.Unlock()
	return mock.DeleteObjectFunc(contextMoqParam, deleteObjectInput)
}

// DeleteObjectCalls gets all the calls that were made to DeleteObject.
// Check the length with:
//
//	len(mockedBackend.DeleteObjectCalls())
func (mock *BackendMock) DeleteObjectCalls() []struct {
	ContextMoqParam   context.Context
	DeleteObjectInput *s3.DeleteObjectInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		DeleteObjectInput *s3.DeleteObjectInput
	}
	mock.lockDeleteObject.RLock()
	calls = mock.calls.DeleteObject
	mock.lockDeleteObject.RUnlock()
	return calls
}

// DeleteObjects calls DeleteObjectsFunc.
func (mock *BackendMock) DeleteObjects(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteObjectsResult, error) {
	if mock.DeleteObjectsFunc == nil {
		panic("BackendMock.DeleteObjectsFunc: method is nil but Backend.DeleteObjects was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		DeleteObjectsInput *s3.DeleteObjectsInput
	}{
		ContextMoqParam:    contextMoqParam,
		DeleteObjectsInput: deleteObjectsInput,
	}
	mock.lockDeleteObjects.Lock()
	mock.calls.DeleteObjects = append(mock.calls.DeleteObjects, callInfo)
	mock.lockDeleteObjects.Unlock()
	return mock.DeleteObjectsFunc(contextMoqParam, deleteObjectsInput)
}

// DeleteObjectsCalls gets all the calls that were made to DeleteObjects.
// Check the length with:
//
//	len(mockedBackend.DeleteObjectsCalls())
func (mock *BackendMock) DeleteObjectsCalls() []struct {
	ContextMoqParam    context.Context
	DeleteObjectsInput *s3.DeleteObjectsInput
} {
	var calls []struct {
		ContextMoqParam    context.Context
		DeleteObjectsInput *s3.DeleteObjectsInput
	}
	mock.lockDeleteObjects.RLock()
	calls = mock.calls.DeleteObjects
	mock.lockDeleteObjects.RUnlock()
	return calls
}

// GetBucketAcl calls GetBucketAclFunc.
func (mock *BackendMock) GetBucketAcl(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error) {
	if mock.GetBucketAclFunc == nil {
		panic("BackendMock.GetBucketAclFunc: method is nil but Backend.GetBucketAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		GetBucketAclInput *s3.GetBucketAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		GetBucketAclInput: getBucketAclInput,
	}
	mock.lockGetBucketAcl.Lock()
	mock.calls.GetBucketAcl = append(mock.calls.GetBucketAcl, callInfo)
	mock.lockGetBucketAcl.Unlock()
	return mock.GetBucketAclFunc(contextMoqParam, getBucketAclInput)
}

// GetBucketAclCalls gets all the calls that were made to GetBucketAcl.
// Check the length with:
//
//	len(mockedBackend.GetBucketAclCalls())
func (mock *BackendMock) GetBucketAclCalls() []struct {
	ContextMoqParam   context.Context
	GetBucketAclInput *s3.GetBucketAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		GetBucketAclInput *s3.GetBucketAclInput
	}
	mock.lockGetBucketAcl.RLock()
	calls = mock.calls.GetBucketAcl
	mock.lockGetBucketAcl.RUnlock()
	return calls
}

// GetObject calls GetObjectFunc.
func (mock *BackendMock) GetObject(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput, writer io.Writer) (*s3.GetObjectOutput, error) {
	if mock.GetObjectFunc == nil {
		panic("BackendMock.GetObjectFunc: method is nil but Backend.GetObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		GetObjectInput  *s3.GetObjectInput
		Writer          io.Writer
	}{
		ContextMoqParam: contextMoqParam,
		GetObjectInput:  getObjectInput,
		Writer:          writer,
	}
	mock.lockGetObject.Lock()
	mock.calls.GetObject = append(mock.calls.GetObject, callInfo)
	mock.lockGetObject.Unlock()
	return mock.GetObjectFunc(contextMoqParam, getObjectInput, writer)
}

// GetObjectCalls gets all the calls that were made to GetObject.
// Check the length with:
//
//	len(mockedBackend.GetObjectCalls())
func (mock *BackendMock) GetObjectCalls() []struct {
	ContextMoqParam context.Context
	GetObjectInput  *s3.GetObjectInput
	Writer          io.Writer
} {
	var calls []struct {
		ContextMoqParam context.Context
		GetObjectInput  *s3.GetObjectInput
		Writer          io.Writer
	}
	mock.lockGetObject.RLock()
	calls = mock.calls.GetObject
	mock.lockGetObject.RUnlock()
	return calls
}

// GetObjectAcl calls GetObjectAclFunc.
func (mock *BackendMock) GetObjectAcl(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
	if mock.GetObjectAclFunc == nil {
		panic("BackendMock.GetObjectAclFunc: method is nil but Backend.GetObjectAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		GetObjectAclInput *s3.GetObjectAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		GetObjectAclInput: getObjectAclInput,
	}
	mock.lockGetObjectAcl.Lock()
	mock.calls.GetObjectAcl = append(mock.calls.GetObjectAcl, callInfo)
	mock.lockGetObjectAcl.Unlock()
	return mock.GetObjectAclFunc(contextMoqParam, getObjectAclInput)
}

// GetObjectAclCalls gets all the calls that were made to GetObjectAcl.
// Check the length with:
//
//	len(mockedBackend.GetObjectAclCalls())
func (mock *BackendMock) GetObjectAclCalls() []struct {
	ContextMoqParam   context.Context
	GetObjectAclInput *s3.GetObjectAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		GetObjectAclInput *s3.GetObjectAclInput
	}
	mock.lockGetObjectAcl.RLock()
	calls = mock.calls.GetObjectAcl
	mock.lockGetObjectAcl.RUnlock()
	return calls
}

// GetObjectAttributes calls GetObjectAttributesFunc.
func (mock *BackendMock) GetObjectAttributes(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
	if mock.GetObjectAttributesFunc == nil {
		panic("BackendMock.GetObjectAttributesFunc: method is nil but Backend.GetObjectAttributes was just called")
	}
	callInfo := struct {
		ContextMoqParam          context.Context
		GetObjectAttributesInput *s3.GetObjectAttributesInput
	}{
		ContextMoqParam:          contextMoqParam,
		GetObjectAttributesInput: getObjectAttributesInput,
	}
	mock.lockGetObjectAttributes.Lock()
	mock.calls.GetObjectAttributes = append(mock.calls.GetObjectAttributes, callInfo)
	mock.lockGetObjectAttributes.Unlock()
	return mock.GetObjectAttributesFunc(contextMoqParam, getObjectAttributesInput)
}

// GetObjectAttributesCalls gets all the calls that were made to GetObjectAttributes.
// Check the length with:
//
//	len(mockedBackend.GetObjectAttributesCalls())
func (mock *BackendMock) GetObjectAttributesCalls() []struct {
	ContextMoqParam          context.Context
	GetObjectAttributesInput *s3.GetObjectAttributesInput
} {
	var calls []struct {
		ContextMoqParam          context.Context
		GetObjectAttributesInput *s3.GetObjectAttributesInput
	}
	mock.lockGetObjectAttributes.RLock()
	calls = mock.calls.GetObjectAttributes
	mock.lockGetObjectAttributes.RUnlock()
	return calls
}

// GetTags calls GetTagsFunc.
func (mock *BackendMock) GetTags(contextMoqParam context.Context, bucket string, object string) (map[string]string, error) {
	if mock.GetTagsFunc == nil {
		panic("BackendMock.GetTagsFunc: method is nil but Backend.GetTags was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
	}
	mock.lockGetTags.Lock()
	mock.calls.GetTags = append(mock.calls.GetTags, callInfo)
	mock.lockGetTags.Unlock()
	return mock.GetTagsFunc(contextMoqParam, bucket, object)
}

// GetTagsCalls gets all the calls that were made to GetTags.
// Check the length with:
//
//	len(mockedBackend.GetTagsCalls())
func (mock *BackendMock) GetTagsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}
	mock.lockGetTags.RLock()
	calls = mock.calls.GetTags
	mock.lockGetTags.RUnlock()
	return calls
}

// HeadBucket calls HeadBucketFunc.
func (mock *BackendMock) HeadBucket(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
	if mock.HeadBucketFunc == nil {
		panic("BackendMock.HeadBucketFunc: method is nil but Backend.HeadBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		HeadBucketInput *s3.HeadBucketInput
	}{
		ContextMoqParam: contextMoqParam,
		HeadBucketInput: headBucketInput,
	}
	mock.lockHeadBucket.Lock()
	mock.calls.HeadBucket = append(mock.calls.HeadBucket, callInfo)
	mock.lockHeadBucket.Unlock()
	return mock.HeadBucketFunc(contextMoqParam, headBucketInput)
}

// HeadBucketCalls gets all the calls that were made to HeadBucket.
// Check the length with:
//
//	len(mockedBackend.HeadBucketCalls())
func (mock *BackendMock) HeadBucketCalls() []struct {
	ContextMoqParam context.Context
	HeadBucketInput *s3.HeadBucketInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		HeadBucketInput *s3.HeadBucketInput
	}
	mock.lockHeadBucket.RLock()
	calls = mock.calls.HeadBucket
	mock.lockHeadBucket.RUnlock()
	return calls
}

// HeadObject calls HeadObjectFunc.
func (mock *BackendMock) HeadObject(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
	if mock.HeadObjectFunc == nil {
		panic("BackendMock.HeadObjectFunc: method is nil but Backend.HeadObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		HeadObjectInput *s3.HeadObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		HeadObjectInput: headObjectInput,
	}
	mock.lockHeadObject.Lock()
	mock.calls.HeadObject = append(mock.calls.HeadObject, callInfo)
	mock.lockHeadObject.Unlock()
	return mock.HeadObjectFunc(contextMoqParam, headObjectInput)
}

// HeadObjectCalls gets all the calls that were made to HeadObject.
// Check the length with:
//
//	len(mockedBackend.HeadObjectCalls())
func (mock *BackendMock) HeadObjectCalls() []struct {
	ContextMoqParam context.Context
	HeadObjectInput *s3.HeadObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		HeadObjectInput *s3.HeadObjectInput
	}
	mock.lockHeadObject.RLock()
	calls = mock.calls.HeadObject
	mock.lockHeadObject.RUnlock()
	return calls
}

// ListBuckets calls ListBucketsFunc.
func (mock *BackendMock) ListBuckets(contextMoqParam context.Context, owner string, isRoot bool) (s3response.ListAllMyBucketsResult, error) {
	if mock.ListBucketsFunc == nil {
		panic("BackendMock.ListBucketsFunc: method is nil but Backend.ListBuckets was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Owner           string
		IsRoot          bool
	}{
		ContextMoqParam: contextMoqParam,
		Owner:           owner,
		IsRoot:          isRoot,
	}
	mock.lockListBuckets.Lock()
	mock.calls.ListBuckets = append(mock.calls.ListBuckets, callInfo)
	mock.lockListBuckets.Unlock()
	return mock.ListBucketsFunc(contextMoqParam, owner, isRoot)
}

// ListBucketsCalls gets all the calls that were made to ListBuckets.
// Check the length with:
//
//	len(mockedBackend.ListBucketsCalls())
func (mock *BackendMock) ListBucketsCalls() []struct {
	ContextMoqParam context.Context
	Owner           string
	IsRoot          bool
} {
	var calls []struct {
		ContextMoqParam context.Context
		Owner           string
		IsRoot          bool
	}
	mock.lockListBuckets.RLock()
	calls = mock.calls.ListBuckets
	mock.lockListBuckets.RUnlock()
	return calls
}

// ListMultipartUploads calls ListMultipartUploadsFunc.
func (mock *BackendMock) ListMultipartUploads(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
	if mock.ListMultipartUploadsFunc == nil {
		panic("BackendMock.ListMultipartUploadsFunc: method is nil but Backend.ListMultipartUploads was just called")
	}
	callInfo := struct {
		ContextMoqParam           context.Context
		ListMultipartUploadsInput *s3.ListMultipartUploadsInput
	}{
		ContextMoqParam:           contextMoqParam,
		ListMultipartUploadsInput: listMultipartUploadsInput,
	}
	mock.lockListMultipartUploads.Lock()
	mock.calls.ListMultipartUploads = append(mock.calls.ListMultipartUploads, callInfo)
	mock.lockListMultipartUploads.Unlock()
	return mock.ListMultipartUploadsFunc(contextMoqParam, listMultipartUploadsInput)
}

// ListMultipartUploadsCalls gets all the calls that were made to ListMultipartUploads.
// Check the length with:
//
//	len(mockedBackend.ListMultipartUploadsCalls())
func (mock *BackendMock) ListMultipartUploadsCalls() []struct {
	ContextMoqParam           context.Context
	ListMultipartUploadsInput *s3.ListMultipartUploadsInput
} {
	var calls []struct {
		ContextMoqParam           context.Context
		ListMultipartUploadsInput *s3.ListMultipartUploadsInput
	}
	mock.lockListMultipartUploads.RLock()
	calls = mock.calls.ListMultipartUploads
	mock.lockListMultipartUploads.RUnlock()
	return calls
}

// ListObjects calls ListObjectsFunc.
func (mock *BackendMock) ListObjects(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
	if mock.ListObjectsFunc == nil {
		panic("BackendMock.ListObjectsFunc: method is nil but Backend.ListObjects was just called")
	}
	callInfo := struct {
		ContextMoqParam  context.Context
		ListObjectsInput *s3.ListObjectsInput
	}{
		ContextMoqParam:  contextMoqParam,
		ListObjectsInput: listObjectsInput,
	}
	mock.lockListObjects.Lock()
	mock.calls.ListObjects = append(mock.calls.ListObjects, callInfo)
	mock.lockListObjects.Unlock()
	return mock.ListObjectsFunc(contextMoqParam, listObjectsInput)
}

// ListObjectsCalls gets all the calls that were made to ListObjects.
// Check the length with:
//
//	len(mockedBackend.ListObjectsCalls())
func (mock *BackendMock) ListObjectsCalls() []struct {
	ContextMoqParam  context.Context
	ListObjectsInput *s3.ListObjectsInput
} {
	var calls []struct {
		ContextMoqParam  context.Context
		ListObjectsInput *s3.ListObjectsInput
	}
	mock.lockListObjects.RLock()
	calls = mock.calls.ListObjects
	mock.lockListObjects.RUnlock()
	return calls
}

// ListObjectsV2 calls ListObjectsV2Func.
func (mock *BackendMock) ListObjectsV2(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
	if mock.ListObjectsV2Func == nil {
		panic("BackendMock.ListObjectsV2Func: method is nil but Backend.ListObjectsV2 was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		ListObjectsV2Input *s3.ListObjectsV2Input
	}{
		ContextMoqParam:    contextMoqParam,
		ListObjectsV2Input: listObjectsV2Input,
	}
	mock.lockListObjectsV2.Lock()
	mock.calls.ListObjectsV2 = append(mock.calls.ListObjectsV2, callInfo)
	mock.lockListObjectsV2.Unlock()
	return mock.ListObjectsV2Func(contextMoqParam, listObjectsV2Input)
}

// ListObjectsV2Calls gets all the calls that were made to ListObjectsV2.
// Check the length with:
//
//	len(mockedBackend.ListObjectsV2Calls())
func (mock *BackendMock) ListObjectsV2Calls() []struct {
	ContextMoqParam    context.Context
	ListObjectsV2Input *s3.ListObjectsV2Input
} {
	var calls []struct {
		ContextMoqParam    context.Context
		ListObjectsV2Input *s3.ListObjectsV2Input
	}
	mock.lockListObjectsV2.RLock()
	calls = mock.calls.ListObjectsV2
	mock.lockListObjectsV2.RUnlock()
	return calls
}

// ListParts calls ListPartsFunc.
func (mock *BackendMock) ListParts(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error) {
	if mock.ListPartsFunc == nil {
		panic("BackendMock.ListPartsFunc: method is nil but Backend.ListParts was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		ListPartsInput  *s3.ListPartsInput
	}{
		ContextMoqParam: contextMoqParam,
		ListPartsInput:  listPartsInput,
	}
	mock.lockListParts.Lock()
	mock.calls.ListParts = append(mock.calls.ListParts, callInfo)
	mock.lockListParts.Unlock()
	return mock.ListPartsFunc(contextMoqParam, listPartsInput)
}

// ListPartsCalls gets all the calls that were made to ListParts.
// Check the length with:
//
//	len(mockedBackend.ListPartsCalls())
func (mock *BackendMock) ListPartsCalls() []struct {
	ContextMoqParam context.Context
	ListPartsInput  *s3.ListPartsInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		ListPartsInput  *s3.ListPartsInput
	}
	mock.lockListParts.RLock()
	calls = mock.calls.ListParts
	mock.lockListParts.RUnlock()
	return calls
}

// PutBucketAcl calls PutBucketAclFunc.
func (mock *BackendMock) PutBucketAcl(contextMoqParam context.Context, bucket string, data []byte) error {
	if mock.PutBucketAclFunc == nil {
		panic("BackendMock.PutBucketAclFunc: method is nil but Backend.PutBucketAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Data            []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Data:            data,
	}
	mock.lockPutBucketAcl.Lock()
	mock.calls.PutBucketAcl = append(mock.calls.PutBucketAcl, callInfo)
	mock.lockPutBucketAcl.Unlock()
	return mock.PutBucketAclFunc(contextMoqParam, bucket, data)
}

// PutBucketAclCalls gets all the calls that were made to PutBucketAcl.
// Check the length with:
//
//	len(mockedBackend.PutBucketAclCalls())
func (mock *BackendMock) PutBucketAclCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Data            []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Data            []byte
	}
	mock.lockPutBucketAcl.RLock()
	calls = mock.calls.PutBucketAcl
	mock.lockPutBucketAcl.RUnlock()
	return calls
}

// PutObject calls PutObjectFunc.
func (mock *BackendMock) PutObject(contextMoqParam context.Context, putObjectInput *s3.PutObjectInput) (string, error) {
	if mock.PutObjectFunc == nil {
		panic("BackendMock.PutObjectFunc: method is nil but Backend.PutObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		PutObjectInput  *s3.PutObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		PutObjectInput:  putObjectInput,
	}
	mock.lockPutObject.Lock()
	mock.calls.PutObject = append(mock.calls.PutObject, callInfo)
	mock.lockPutObject.Unlock()
	return mock.PutObjectFunc(contextMoqParam, putObjectInput)
}

// PutObjectCalls gets all the calls that were made to PutObject.
// Check the length with:
//
//	len(mockedBackend.PutObjectCalls())
func (mock *BackendMock) PutObjectCalls() []struct {
	ContextMoqParam context.Context
	PutObjectInput  *s3.PutObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		PutObjectInput  *s3.PutObjectInput
	}
	mock.lockPutObject.RLock()
	calls = mock.calls.PutObject
	mock.lockPutObject.RUnlock()
	return calls
}

// PutObjectAcl calls PutObjectAclFunc.
func (mock *BackendMock) PutObjectAcl(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error {
	if mock.PutObjectAclFunc == nil {
		panic("BackendMock.PutObjectAclFunc: method is nil but Backend.PutObjectAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		PutObjectAclInput *s3.PutObjectAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		PutObjectAclInput: putObjectAclInput,
	}
	mock.lockPutObjectAcl.Lock()
	mock.calls.PutObjectAcl = append(mock.calls.PutObjectAcl, callInfo)
	mock.lockPutObjectAcl.Unlock()
	return mock.PutObjectAclFunc(contextMoqParam, putObjectAclInput)
}

// PutObjectAclCalls gets all the calls that were made to PutObjectAcl.
// Check the length with:
//
//	len(mockedBackend.PutObjectAclCalls())
func (mock *BackendMock) PutObjectAclCalls() []struct {
	ContextMoqParam   context.Context
	PutObjectAclInput *s3.PutObjectAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		PutObjectAclInput *s3.PutObjectAclInput
	}
	mock.lockPutObjectAcl.RLock()
	calls = mock.calls.PutObjectAcl
	mock.lockPutObjectAcl.RUnlock()
	return calls
}

// RemoveTags calls RemoveTagsFunc.
func (mock *BackendMock) RemoveTags(contextMoqParam context.Context, bucket string, object string) error {
	if mock.RemoveTagsFunc == nil {
		panic("BackendMock.RemoveTagsFunc: method is nil but Backend.RemoveTags was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
	}
	mock.lockRemoveTags.Lock()
	mock.calls.RemoveTags = append(mock.calls.RemoveTags, callInfo)
	mock.lockRemoveTags.Unlock()
	return mock.RemoveTagsFunc(contextMoqParam, bucket, object)
}

// RemoveTagsCalls gets all the calls that were made to RemoveTags.
// Check the length with:
//
//	len(mockedBackend.RemoveTagsCalls())
func (mock *BackendMock) RemoveTagsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}
	mock.lockRemoveTags.RLock()
	calls = mock.calls.RemoveTags
	mock.lockRemoveTags.RUnlock()
	return calls
}

// RestoreObject calls RestoreObjectFunc.
func (mock *BackendMock) RestoreObject(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error {
	if mock.RestoreObjectFunc == nil {
		panic("BackendMock.RestoreObjectFunc: method is nil but Backend.RestoreObject was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		RestoreObjectInput *s3.RestoreObjectInput
	}{
		ContextMoqParam:    contextMoqParam,
		RestoreObjectInput: restoreObjectInput,
	}
	mock.lockRestoreObject.Lock()
	mock.calls.RestoreObject = append(mock.calls.RestoreObject, callInfo)
	mock.lockRestoreObject.Unlock()
	return mock.RestoreObjectFunc(contextMoqParam, restoreObjectInput)
}

// RestoreObjectCalls gets all the calls that were made to RestoreObject.
// Check the length with:
//
//	len(mockedBackend.RestoreObjectCalls())
func (mock *BackendMock) RestoreObjectCalls() []struct {
	ContextMoqParam    context.Context
	RestoreObjectInput *s3.RestoreObjectInput
} {
	var calls []struct {
		ContextMoqParam    context.Context
		RestoreObjectInput *s3.RestoreObjectInput
	}
	mock.lockRestoreObject.RLock()
	calls = mock.calls.RestoreObject
	mock.lockRestoreObject.RUnlock()
	return calls
}

// SelectObjectContent calls SelectObjectContentFunc.
func (mock *BackendMock) SelectObjectContent(contextMoqParam context.Context, selectObjectContentInput *s3.SelectObjectContentInput) (s3response.SelectObjectContentResult, error) {
	if mock.SelectObjectContentFunc == nil {
		panic("BackendMock.SelectObjectContentFunc: method is nil but Backend.SelectObjectContent was just called")
	}
	callInfo := struct {
		ContextMoqParam          context.Context
		SelectObjectContentInput *s3.SelectObjectContentInput
	}{
		ContextMoqParam:          contextMoqParam,
		SelectObjectContentInput: selectObjectContentInput,
	}
	mock.lockSelectObjectContent.Lock()
	mock.calls.SelectObjectContent = append(mock.calls.SelectObjectContent, callInfo)
	mock.lockSelectObjectContent.Unlock()
	return mock.SelectObjectContentFunc(contextMoqParam, selectObjectContentInput)
}

// SelectObjectContentCalls gets all the calls that were made to SelectObjectContent.
// Check the length with:
//
//	len(mockedBackend.SelectObjectContentCalls())
func (mock *BackendMock) SelectObjectContentCalls() []struct {
	ContextMoqParam          context.Context
	SelectObjectContentInput *s3.SelectObjectContentInput
} {
	var calls []struct {
		ContextMoqParam          context.Context
		SelectObjectContentInput *s3.SelectObjectContentInput
	}
	mock.lockSelectObjectContent.RLock()
	calls = mock.calls.SelectObjectContent
	mock.lockSelectObjectContent.RUnlock()
	return calls
}

// SetTags calls SetTagsFunc.
func (mock *BackendMock) SetTags(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
	if mock.SetTagsFunc == nil {
		panic("BackendMock.SetTagsFunc: method is nil but Backend.SetTags was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		Tags            map[string]string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		Tags:            tags,
	}
	mock.lockSetTags.Lock()
	mock.calls.SetTags = append(mock.calls.SetTags, callInfo)
	mock.lockSetTags.Unlock()
	return mock.SetTagsFunc(contextMoqParam, bucket, object, tags)
}

// SetTagsCalls gets all the calls that were made to SetTags.
// Check the length with:
//
//	len(mockedBackend.SetTagsCalls())
func (mock *BackendMock) SetTagsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	Tags            map[string]string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		Tags            map[string]string
	}
	mock.lockSetTags.RLock()
	calls = mock.calls.SetTags
	mock.lockSetTags.RUnlock()
	return calls
}

// Shutdown calls ShutdownFunc.
func (mock *BackendMock) Shutdown() {
	if mock.ShutdownFunc == nil {
		panic("BackendMock.ShutdownFunc: method is nil but Backend.Shutdown was just called")
	}
	callInfo := struct {
	}{}
	mock.lockShutdown.Lock()
	mock.calls.Shutdown = append(mock.calls.Shutdown, callInfo)
	mock.lockShutdown.Unlock()
	mock.ShutdownFunc()
}

// ShutdownCalls gets all the calls that were made to Shutdown.
// Check the length with:
//
//	len(mockedBackend.ShutdownCalls())
func (mock *BackendMock) ShutdownCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockShutdown.RLock()
	calls = mock.calls.Shutdown
	mock.lockShutdown.RUnlock()
	return calls
}

// String calls StringFunc.
func (mock *BackendMock) String() string {
	if mock.StringFunc == nil {
		panic("BackendMock.StringFunc: method is nil but Backend.String was just called")
	}
	callInfo := struct {
	}{}
	mock.lockString.Lock()
	mock.calls.String = append(mock.calls.String, callInfo)
	mock.lockString.Unlock()
	return mock.StringFunc()
}

// StringCalls gets all the calls that were made to String.
// Check the length with:
//
//	len(mockedBackend.StringCalls())
func (mock *BackendMock) StringCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockString.RLock()
	calls = mock.calls.String
	mock.lockString.RUnlock()
	return calls
}

// UploadPart calls UploadPartFunc.
func (mock *BackendMock) UploadPart(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (string, error) {
	if mock.UploadPartFunc == nil {
		panic("BackendMock.UploadPartFunc: method is nil but Backend.UploadPart was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		UploadPartInput *s3.UploadPartInput
	}{
		ContextMoqParam: contextMoqParam,
		UploadPartInput: uploadPartInput,
	}
	mock.lockUploadPart.Lock()
	mock.calls.UploadPart = append(mock.calls.UploadPart, callInfo)
	mock.lockUploadPart.Unlock()
	return mock.UploadPartFunc(contextMoqParam, uploadPartInput)
}

// UploadPartCalls gets all the calls that were made to UploadPart.
// Check the length with:
//
//	len(mockedBackend.UploadPartCalls())
func (mock *BackendMock) UploadPartCalls() []struct {
	ContextMoqParam context.Context
	UploadPartInput *s3.UploadPartInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		UploadPartInput *s3.UploadPartInput
	}
	mock.lockUploadPart.RLock()
	calls = mock.calls.UploadPart
	mock.lockUploadPart.RUnlock()
	return calls
}

// UploadPartCopy calls UploadPartCopyFunc.
func (mock *BackendMock) UploadPartCopy(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyObjectResult, error) {
	if mock.UploadPartCopyFunc == nil {
		panic("BackendMock.UploadPartCopyFunc: method is nil but Backend.UploadPartCopy was just called")
	}
	callInfo := struct {
		ContextMoqParam     context.Context
		UploadPartCopyInput *s3.UploadPartCopyInput
	}{
		ContextMoqParam:     contextMoqParam,
		UploadPartCopyInput: uploadPartCopyInput,
	}
	mock.lockUploadPartCopy.Lock()
	mock.calls.UploadPartCopy = append(mock.calls.UploadPartCopy, callInfo)
	mock.lockUploadPartCopy.Unlock()
	return mock.UploadPartCopyFunc(contextMoqParam, uploadPartCopyInput)
}

// UploadPartCopyCalls gets all the calls that were made to UploadPartCopy.
// Check the length with:
//
//	len(mockedBackend.UploadPartCopyCalls())
func (mock *BackendMock) UploadPartCopyCalls() []struct {
	ContextMoqParam     context.Context
	UploadPartCopyInput *s3.UploadPartCopyInput
} {
	var calls []struct {
		ContextMoqParam     context.Context
		UploadPartCopyInput *s3.UploadPartCopyInput
	}
	mock.lockUploadPartCopy.RLock()
	calls = mock.calls.UploadPartCopy
	mock.lockUploadPartCopy.RUnlock()
	return calls
}