versitygw/s3api/controllers/backend_moq_test.go

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

package controllers

import (
	"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(abortMultipartUploadInput *s3.AbortMultipartUploadInput) error {
//				panic("mock out the AbortMultipartUpload method")
//			},
//			CompleteMultipartUploadFunc: func(completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
//				panic("mock out the CompleteMultipartUpload method")
//			},
//			CopyObjectFunc: func(copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
//				panic("mock out the CopyObject method")
//			},
//			CreateBucketFunc: func(createBucketInput *s3.CreateBucketInput) error {
//				panic("mock out the CreateBucket method")
//			},
//			CreateMultipartUploadFunc: func(createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
//				panic("mock out the CreateMultipartUpload method")
//			},
//			DeleteBucketFunc: func(deleteBucketInput *s3.DeleteBucketInput) error {
//				panic("mock out the DeleteBucket method")
//			},
//			DeleteObjectFunc: func(deleteObjectInput *s3.DeleteObjectInput) error {
//				panic("mock out the DeleteObject method")
//			},
//			DeleteObjectsFunc: func(deleteObjectsInput *s3.DeleteObjectsInput) error {
//				panic("mock out the DeleteObjects method")
//			},
//			GetBucketAclFunc: func(getBucketAclInput *s3.GetBucketAclInput) ([]byte, error) {
//				panic("mock out the GetBucketAcl method")
//			},
//			GetObjectFunc: func(getObjectInput *s3.GetObjectInput, writer io.Writer) (*s3.GetObjectOutput, error) {
//				panic("mock out the GetObject method")
//			},
//			GetObjectAclFunc: func(getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
//				panic("mock out the GetObjectAcl method")
//			},
//			GetObjectAttributesFunc: func(getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
//				panic("mock out the GetObjectAttributes method")
//			},
//			GetTagsFunc: func(bucket string, object string) (map[string]string, error) {
//				panic("mock out the GetTags method")
//			},
//			HeadBucketFunc: func(headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
//				panic("mock out the HeadBucket method")
//			},
//			HeadObjectFunc: func(headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
//				panic("mock out the HeadObject method")
//			},
//			ListBucketsFunc: func(owner string, isRoot bool) (s3response.ListAllMyBucketsResult, error) {
//				panic("mock out the ListBuckets method")
//			},
//			ListMultipartUploadsFunc: func(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResponse, error) {
//				panic("mock out the ListMultipartUploads method")
//			},
//			ListObjectsFunc: func(listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
//				panic("mock out the ListObjects method")
//			},
//			ListObjectsV2Func: func(listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
//				panic("mock out the ListObjectsV2 method")
//			},
//			ListPartsFunc: func(listPartsInput *s3.ListPartsInput) (s3response.ListPartsResponse, error) {
//				panic("mock out the ListParts method")
//			},
//			PutBucketAclFunc: func(bucket string, data []byte) error {
//				panic("mock out the PutBucketAcl method")
//			},
//			PutObjectFunc: func(putObjectInput *s3.PutObjectInput) (string, error) {
//				panic("mock out the PutObject method")
//			},
//			PutObjectAclFunc: func(putObjectAclInput *s3.PutObjectAclInput) error {
//				panic("mock out the PutObjectAcl method")
//			},
//			RemoveTagsFunc: func(bucket string, object string) error {
//				panic("mock out the RemoveTags method")
//			},
//			RestoreObjectFunc: func(restoreObjectInput *s3.RestoreObjectInput) error {
//				panic("mock out the RestoreObject method")
//			},
//			SetTagsFunc: func(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(uploadPartInput *s3.UploadPartInput) (string, error) {
//				panic("mock out the UploadPart method")
//			},
//			UploadPartCopyFunc: func(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(abortMultipartUploadInput *s3.AbortMultipartUploadInput) error

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

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

	// CreateBucketFunc mocks the CreateBucket method.
	CreateBucketFunc func(createBucketInput *s3.CreateBucketInput) error

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

	// DeleteBucketFunc mocks the DeleteBucket method.
	DeleteBucketFunc func(deleteBucketInput *s3.DeleteBucketInput) error

	// DeleteObjectFunc mocks the DeleteObject method.
	DeleteObjectFunc func(deleteObjectInput *s3.DeleteObjectInput) error

	// DeleteObjectsFunc mocks the DeleteObjects method.
	DeleteObjectsFunc func(deleteObjectsInput *s3.DeleteObjectsInput) error

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

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

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

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

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

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

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

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

	// ListMultipartUploadsFunc mocks the ListMultipartUploads method.
	ListMultipartUploadsFunc func(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResponse, error)

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

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

	// ListPartsFunc mocks the ListParts method.
	ListPartsFunc func(listPartsInput *s3.ListPartsInput) (s3response.ListPartsResponse, error)

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

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

	// PutObjectAclFunc mocks the PutObjectAcl method.
	PutObjectAclFunc func(putObjectAclInput *s3.PutObjectAclInput) error

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

	// RestoreObjectFunc mocks the RestoreObject method.
	RestoreObjectFunc func(restoreObjectInput *s3.RestoreObjectInput) error

	// SetTagsFunc mocks the SetTags method.
	SetTagsFunc func(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(uploadPartInput *s3.UploadPartInput) (string, error)

	// UploadPartCopyFunc mocks the UploadPartCopy method.
	UploadPartCopyFunc func(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 {
			// AbortMultipartUploadInput is the abortMultipartUploadInput argument value.
			AbortMultipartUploadInput *s3.AbortMultipartUploadInput
		}
		// CompleteMultipartUpload holds details about calls to the CompleteMultipartUpload method.
		CompleteMultipartUpload []struct {
			// CompleteMultipartUploadInput is the completeMultipartUploadInput argument value.
			CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
		}
		// CopyObject holds details about calls to the CopyObject method.
		CopyObject []struct {
			// CopyObjectInput is the copyObjectInput argument value.
			CopyObjectInput *s3.CopyObjectInput
		}
		// CreateBucket holds details about calls to the CreateBucket method.
		CreateBucket []struct {
			// CreateBucketInput is the createBucketInput argument value.
			CreateBucketInput *s3.CreateBucketInput
		}
		// CreateMultipartUpload holds details about calls to the CreateMultipartUpload method.
		CreateMultipartUpload []struct {
			// CreateMultipartUploadInput is the createMultipartUploadInput argument value.
			CreateMultipartUploadInput *s3.CreateMultipartUploadInput
		}
		// DeleteBucket holds details about calls to the DeleteBucket method.
		DeleteBucket []struct {
			// DeleteBucketInput is the deleteBucketInput argument value.
			DeleteBucketInput *s3.DeleteBucketInput
		}
		// DeleteObject holds details about calls to the DeleteObject method.
		DeleteObject []struct {
			// DeleteObjectInput is the deleteObjectInput argument value.
			DeleteObjectInput *s3.DeleteObjectInput
		}
		// DeleteObjects holds details about calls to the DeleteObjects method.
		DeleteObjects []struct {
			// DeleteObjectsInput is the deleteObjectsInput argument value.
			DeleteObjectsInput *s3.DeleteObjectsInput
		}
		// GetBucketAcl holds details about calls to the GetBucketAcl method.
		GetBucketAcl []struct {
			// GetBucketAclInput is the getBucketAclInput argument value.
			GetBucketAclInput *s3.GetBucketAclInput
		}
		// GetObject holds details about calls to the GetObject method.
		GetObject []struct {
			// 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 {
			// GetObjectAclInput is the getObjectAclInput argument value.
			GetObjectAclInput *s3.GetObjectAclInput
		}
		// GetObjectAttributes holds details about calls to the GetObjectAttributes method.
		GetObjectAttributes []struct {
			// GetObjectAttributesInput is the getObjectAttributesInput argument value.
			GetObjectAttributesInput *s3.GetObjectAttributesInput
		}
		// GetTags holds details about calls to the GetTags method.
		GetTags []struct {
			// 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 {
			// HeadBucketInput is the headBucketInput argument value.
			HeadBucketInput *s3.HeadBucketInput
		}
		// HeadObject holds details about calls to the HeadObject method.
		HeadObject []struct {
			// HeadObjectInput is the headObjectInput argument value.
			HeadObjectInput *s3.HeadObjectInput
		}
		// ListBuckets holds details about calls to the ListBuckets method.
		ListBuckets []struct {
			// 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 {
			// ListMultipartUploadsInput is the listMultipartUploadsInput argument value.
			ListMultipartUploadsInput *s3.ListMultipartUploadsInput
		}
		// ListObjects holds details about calls to the ListObjects method.
		ListObjects []struct {
			// ListObjectsInput is the listObjectsInput argument value.
			ListObjectsInput *s3.ListObjectsInput
		}
		// ListObjectsV2 holds details about calls to the ListObjectsV2 method.
		ListObjectsV2 []struct {
			// ListObjectsV2Input is the listObjectsV2Input argument value.
			ListObjectsV2Input *s3.ListObjectsV2Input
		}
		// ListParts holds details about calls to the ListParts method.
		ListParts []struct {
			// ListPartsInput is the listPartsInput argument value.
			ListPartsInput *s3.ListPartsInput
		}
		// PutBucketAcl holds details about calls to the PutBucketAcl method.
		PutBucketAcl []struct {
			// 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 {
			// PutObjectInput is the putObjectInput argument value.
			PutObjectInput *s3.PutObjectInput
		}
		// PutObjectAcl holds details about calls to the PutObjectAcl method.
		PutObjectAcl []struct {
			// PutObjectAclInput is the putObjectAclInput argument value.
			PutObjectAclInput *s3.PutObjectAclInput
		}
		// RemoveTags holds details about calls to the RemoveTags method.
		RemoveTags []struct {
			// 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 {
			// RestoreObjectInput is the restoreObjectInput argument value.
			RestoreObjectInput *s3.RestoreObjectInput
		}
		// SetTags holds details about calls to the SetTags method.
		SetTags []struct {
			// 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 {
			// UploadPartInput is the uploadPartInput argument value.
			UploadPartInput *s3.UploadPartInput
		}
		// UploadPartCopy holds details about calls to the UploadPartCopy method.
		UploadPartCopy []struct {
			// 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
	lockSetTags                 sync.RWMutex
	lockShutdown                sync.RWMutex
	lockString                  sync.RWMutex
	lockUploadPart              sync.RWMutex
	lockUploadPartCopy          sync.RWMutex
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetObject calls GetObjectFunc.
func (mock *BackendMock) GetObject(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 {
		GetObjectInput *s3.GetObjectInput
		Writer         io.Writer
	}{
		GetObjectInput: getObjectInput,
		Writer:         writer,
	}
	mock.lockGetObject.Lock()
	mock.calls.GetObject = append(mock.calls.GetObject, callInfo)
	mock.lockGetObject.Unlock()
	return mock.GetObjectFunc(getObjectInput, writer)
}

// GetObjectCalls gets all the calls that were made to GetObject.
// Check the length with:
//
//	len(mockedBackend.GetObjectCalls())
func (mock *BackendMock) GetObjectCalls() []struct {
	GetObjectInput *s3.GetObjectInput
	Writer         io.Writer
} {
	var calls []struct {
		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(getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
	if mock.GetObjectAclFunc == nil {
		panic("BackendMock.GetObjectAclFunc: method is nil but Backend.GetObjectAcl was just called")
	}
	callInfo := struct {
		GetObjectAclInput *s3.GetObjectAclInput
	}{
		GetObjectAclInput: getObjectAclInput,
	}
	mock.lockGetObjectAcl.Lock()
	mock.calls.GetObjectAcl = append(mock.calls.GetObjectAcl, callInfo)
	mock.lockGetObjectAcl.Unlock()
	return mock.GetObjectAclFunc(getObjectAclInput)
}

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

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

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

// GetTags calls GetTagsFunc.
func (mock *BackendMock) GetTags(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 {
		Bucket string
		Object string
	}{
		Bucket: bucket,
		Object: object,
	}
	mock.lockGetTags.Lock()
	mock.calls.GetTags = append(mock.calls.GetTags, callInfo)
	mock.lockGetTags.Unlock()
	return mock.GetTagsFunc(bucket, object)
}

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

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

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

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

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

// ListBuckets calls ListBucketsFunc.
func (mock *BackendMock) ListBuckets(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 {
		Owner  string
		IsRoot bool
	}{
		Owner:  owner,
		IsRoot: isRoot,
	}
	mock.lockListBuckets.Lock()
	mock.calls.ListBuckets = append(mock.calls.ListBuckets, callInfo)
	mock.lockListBuckets.Unlock()
	return mock.ListBucketsFunc(owner, isRoot)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetTags calls SetTagsFunc.
func (mock *BackendMock) SetTags(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 {
		Bucket string
		Object string
		Tags   map[string]string
	}{
		Bucket: bucket,
		Object: object,
		Tags:   tags,
	}
	mock.lockSetTags.Lock()
	mock.calls.SetTags = append(mock.calls.SetTags, callInfo)
	mock.lockSetTags.Unlock()
	return mock.SetTagsFunc(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 {
	Bucket string
	Object string
	Tags   map[string]string
} {
	var calls []struct {
		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(uploadPartInput *s3.UploadPartInput) (string, error) {
	if mock.UploadPartFunc == nil {
		panic("BackendMock.UploadPartFunc: method is nil but Backend.UploadPart was just called")
	}
	callInfo := struct {
		UploadPartInput *s3.UploadPartInput
	}{
		UploadPartInput: uploadPartInput,
	}
	mock.lockUploadPart.Lock()
	mock.calls.UploadPart = append(mock.calls.UploadPart, callInfo)
	mock.lockUploadPart.Unlock()
	return mock.UploadPartFunc(uploadPartInput)
}

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

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

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