versitygw/s3api/controllers/backend_moq_test.go

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

package controllers

import (
	"bufio"
	"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")
//			},
//			ChangeBucketOwnerFunc: func(contextMoqParam context.Context, bucket string, newOwner string) error {
//				panic("mock out the ChangeBucketOwner 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, defaultACL []byte) 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")
//			},
//			DeleteBucketTaggingFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucketTagging method")
//			},
//			DeleteObjectFunc: func(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) error {
//				panic("mock out the DeleteObject method")
//			},
//			DeleteObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string) error {
//				panic("mock out the DeleteObjectTagging 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")
//			},
//			GetBucketPolicyFunc: func(contextMoqParam context.Context, bucket string) ([]byte, error) {
//				panic("mock out the GetBucketPolicy method")
//			},
//			GetBucketTaggingFunc: func(contextMoqParam context.Context, bucket string) (map[string]string, error) {
//				panic("mock out the GetBucketTagging method")
//			},
//			GetBucketVersioningFunc: func(contextMoqParam context.Context, bucket string) (*s3.GetBucketVersioningOutput, error) {
//				panic("mock out the GetBucketVersioning 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")
//			},
//			GetObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string) (map[string]string, error) {
//				panic("mock out the GetObjectTagging 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, isAdmin bool) (s3response.ListAllMyBucketsResult, error) {
//				panic("mock out the ListBuckets method")
//			},
//			ListBucketsAndOwnersFunc: func(contextMoqParam context.Context) ([]s3response.Bucket, error) {
//				panic("mock out the ListBucketsAndOwners method")
//			},
//			ListMultipartUploadsFunc: func(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
//				panic("mock out the ListMultipartUploads method")
//			},
//			ListObjectVersionsFunc: func(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
//				panic("mock out the ListObjectVersions 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")
//			},
//			PutBucketPolicyFunc: func(contextMoqParam context.Context, bucket string, policy []byte) error {
//				panic("mock out the PutBucketPolicy method")
//			},
//			PutBucketTaggingFunc: func(contextMoqParam context.Context, bucket string, tags map[string]string) error {
//				panic("mock out the PutBucketTagging method")
//			},
//			PutBucketVersioningFunc: func(contextMoqParam context.Context, putBucketVersioningInput *s3.PutBucketVersioningInput) error {
//				panic("mock out the PutBucketVersioning 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")
//			},
//			PutObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
//				panic("mock out the PutObjectTagging method")
//			},
//			RestoreObjectFunc: func(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error {
//				panic("mock out the RestoreObject method")
//			},
//			SelectObjectContentFunc: func(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer) {
//				panic("mock out the SelectObjectContent 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

	// ChangeBucketOwnerFunc mocks the ChangeBucketOwner method.
	ChangeBucketOwnerFunc func(contextMoqParam context.Context, bucket string, newOwner string) 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, defaultACL []byte) 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

	// DeleteBucketTaggingFunc mocks the DeleteBucketTagging method.
	DeleteBucketTaggingFunc func(contextMoqParam context.Context, bucket string) error

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

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

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

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

	// GetBucketPolicyFunc mocks the GetBucketPolicy method.
	GetBucketPolicyFunc func(contextMoqParam context.Context, bucket string) ([]byte, error)

	// GetBucketTaggingFunc mocks the GetBucketTagging method.
	GetBucketTaggingFunc func(contextMoqParam context.Context, bucket string) (map[string]string, error)

	// GetBucketVersioningFunc mocks the GetBucketVersioning method.
	GetBucketVersioningFunc func(contextMoqParam context.Context, bucket string) (*s3.GetBucketVersioningOutput, 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)

	// GetObjectTaggingFunc mocks the GetObjectTagging method.
	GetObjectTaggingFunc 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, isAdmin bool) (s3response.ListAllMyBucketsResult, error)

	// ListBucketsAndOwnersFunc mocks the ListBucketsAndOwners method.
	ListBucketsAndOwnersFunc func(contextMoqParam context.Context) ([]s3response.Bucket, error)

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

	// ListObjectVersionsFunc mocks the ListObjectVersions method.
	ListObjectVersionsFunc func(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, 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

	// PutBucketPolicyFunc mocks the PutBucketPolicy method.
	PutBucketPolicyFunc func(contextMoqParam context.Context, bucket string, policy []byte) error

	// PutBucketTaggingFunc mocks the PutBucketTagging method.
	PutBucketTaggingFunc func(contextMoqParam context.Context, bucket string, tags map[string]string) error

	// PutBucketVersioningFunc mocks the PutBucketVersioning method.
	PutBucketVersioningFunc func(contextMoqParam context.Context, putBucketVersioningInput *s3.PutBucketVersioningInput) 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

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

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

	// SelectObjectContentFunc mocks the SelectObjectContent method.
	SelectObjectContentFunc func(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer)

	// 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
		}
		// ChangeBucketOwner holds details about calls to the ChangeBucketOwner method.
		ChangeBucketOwner []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// NewOwner is the newOwner argument value.
			NewOwner string
		}
		// 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
			// DefaultACL is the defaultACL argument value.
			DefaultACL []byte
		}
		// 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
		}
		// DeleteBucketTagging holds details about calls to the DeleteBucketTagging method.
		DeleteBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// 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
		}
		// DeleteObjectTagging holds details about calls to the DeleteObjectTagging method.
		DeleteObjectTagging []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
		}
		// 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
		}
		// GetBucketPolicy holds details about calls to the GetBucketPolicy method.
		GetBucketPolicy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketTagging holds details about calls to the GetBucketTagging method.
		GetBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketVersioning holds details about calls to the GetBucketVersioning method.
		GetBucketVersioning []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// 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
		}
		// GetObjectTagging holds details about calls to the GetObjectTagging method.
		GetObjectTagging []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
			// IsAdmin is the isAdmin argument value.
			IsAdmin bool
		}
		// ListBucketsAndOwners holds details about calls to the ListBucketsAndOwners method.
		ListBucketsAndOwners []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
		}
		// 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
		}
		// ListObjectVersions holds details about calls to the ListObjectVersions method.
		ListObjectVersions []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectVersionsInput is the listObjectVersionsInput argument value.
			ListObjectVersionsInput *s3.ListObjectVersionsInput
		}
		// 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
		}
		// PutBucketPolicy holds details about calls to the PutBucketPolicy method.
		PutBucketPolicy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Policy is the policy argument value.
			Policy []byte
		}
		// PutBucketTagging holds details about calls to the PutBucketTagging method.
		PutBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Tags is the tags argument value.
			Tags map[string]string
		}
		// PutBucketVersioning holds details about calls to the PutBucketVersioning method.
		PutBucketVersioning []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// PutBucketVersioningInput is the putBucketVersioningInput argument value.
			PutBucketVersioningInput *s3.PutBucketVersioningInput
		}
		// 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
		}
		// PutObjectTagging holds details about calls to the PutObjectTagging method.
		PutObjectTagging []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
		}
		// 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 {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Input is the input argument value.
			Input *s3.SelectObjectContentInput
		}
		// 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
	lockChangeBucketOwner       sync.RWMutex
	lockCompleteMultipartUpload sync.RWMutex
	lockCopyObject              sync.RWMutex
	lockCreateBucket            sync.RWMutex
	lockCreateMultipartUpload   sync.RWMutex
	lockDeleteBucket            sync.RWMutex
	lockDeleteBucketTagging     sync.RWMutex
	lockDeleteObject            sync.RWMutex
	lockDeleteObjectTagging     sync.RWMutex
	lockDeleteObjects           sync.RWMutex
	lockGetBucketAcl            sync.RWMutex
	lockGetBucketPolicy         sync.RWMutex
	lockGetBucketTagging        sync.RWMutex
	lockGetBucketVersioning     sync.RWMutex
	lockGetObject               sync.RWMutex
	lockGetObjectAcl            sync.RWMutex
	lockGetObjectAttributes     sync.RWMutex
	lockGetObjectTagging        sync.RWMutex
	lockHeadBucket              sync.RWMutex
	lockHeadObject              sync.RWMutex
	lockListBuckets             sync.RWMutex
	lockListBucketsAndOwners    sync.RWMutex
	lockListMultipartUploads    sync.RWMutex
	lockListObjectVersions      sync.RWMutex
	lockListObjects             sync.RWMutex
	lockListObjectsV2           sync.RWMutex
	lockListParts               sync.RWMutex
	lockPutBucketAcl            sync.RWMutex
	lockPutBucketPolicy         sync.RWMutex
	lockPutBucketTagging        sync.RWMutex
	lockPutBucketVersioning     sync.RWMutex
	lockPutObject               sync.RWMutex
	lockPutObjectAcl            sync.RWMutex
	lockPutObjectTagging        sync.RWMutex
	lockRestoreObject           sync.RWMutex
	lockSelectObjectContent     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
}

// ChangeBucketOwner calls ChangeBucketOwnerFunc.
func (mock *BackendMock) ChangeBucketOwner(contextMoqParam context.Context, bucket string, newOwner string) error {
	if mock.ChangeBucketOwnerFunc == nil {
		panic("BackendMock.ChangeBucketOwnerFunc: method is nil but Backend.ChangeBucketOwner was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		NewOwner        string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		NewOwner:        newOwner,
	}
	mock.lockChangeBucketOwner.Lock()
	mock.calls.ChangeBucketOwner = append(mock.calls.ChangeBucketOwner, callInfo)
	mock.lockChangeBucketOwner.Unlock()
	return mock.ChangeBucketOwnerFunc(contextMoqParam, bucket, newOwner)
}

// ChangeBucketOwnerCalls gets all the calls that were made to ChangeBucketOwner.
// Check the length with:
//
//	len(mockedBackend.ChangeBucketOwnerCalls())
func (mock *BackendMock) ChangeBucketOwnerCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	NewOwner        string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		NewOwner        string
	}
	mock.lockChangeBucketOwner.RLock()
	calls = mock.calls.ChangeBucketOwner
	mock.lockChangeBucketOwner.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, defaultACL []byte) 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
		DefaultACL        []byte
	}{
		ContextMoqParam:   contextMoqParam,
		CreateBucketInput: createBucketInput,
		DefaultACL:        defaultACL,
	}
	mock.lockCreateBucket.Lock()
	mock.calls.CreateBucket = append(mock.calls.CreateBucket, callInfo)
	mock.lockCreateBucket.Unlock()
	return mock.CreateBucketFunc(contextMoqParam, createBucketInput, defaultACL)
}

// 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
	DefaultACL        []byte
} {
	var calls []struct {
		ContextMoqParam   context.Context
		CreateBucketInput *s3.CreateBucketInput
		DefaultACL        []byte
	}
	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
}

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

// DeleteBucketTaggingCalls gets all the calls that were made to DeleteBucketTagging.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketTaggingCalls())
func (mock *BackendMock) DeleteBucketTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucketTagging.RLock()
	calls = mock.calls.DeleteBucketTagging
	mock.lockDeleteBucketTagging.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
}

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

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

// DeleteObjects calls DeleteObjectsFunc.
func (mock *BackendMock) DeleteObjects(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteResult, 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
}

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

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

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

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

// GetBucketVersioning calls GetBucketVersioningFunc.
func (mock *BackendMock) GetBucketVersioning(contextMoqParam context.Context, bucket string) (*s3.GetBucketVersioningOutput, error) {
	if mock.GetBucketVersioningFunc == nil {
		panic("BackendMock.GetBucketVersioningFunc: method is nil but Backend.GetBucketVersioning was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketVersioning.Lock()
	mock.calls.GetBucketVersioning = append(mock.calls.GetBucketVersioning, callInfo)
	mock.lockGetBucketVersioning.Unlock()
	return mock.GetBucketVersioningFunc(contextMoqParam, bucket)
}

// GetBucketVersioningCalls gets all the calls that were made to GetBucketVersioning.
// Check the length with:
//
//	len(mockedBackend.GetBucketVersioningCalls())
func (mock *BackendMock) GetBucketVersioningCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketVersioning.RLock()
	calls = mock.calls.GetBucketVersioning
	mock.lockGetBucketVersioning.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
}

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

// GetObjectTaggingCalls gets all the calls that were made to GetObjectTagging.
// Check the length with:
//
//	len(mockedBackend.GetObjectTaggingCalls())
func (mock *BackendMock) GetObjectTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}
	mock.lockGetObjectTagging.RLock()
	calls = mock.calls.GetObjectTagging
	mock.lockGetObjectTagging.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, isAdmin 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
		IsAdmin         bool
	}{
		ContextMoqParam: contextMoqParam,
		Owner:           owner,
		IsAdmin:         isAdmin,
	}
	mock.lockListBuckets.Lock()
	mock.calls.ListBuckets = append(mock.calls.ListBuckets, callInfo)
	mock.lockListBuckets.Unlock()
	return mock.ListBucketsFunc(contextMoqParam, owner, isAdmin)
}

// 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
	IsAdmin         bool
} {
	var calls []struct {
		ContextMoqParam context.Context
		Owner           string
		IsAdmin         bool
	}
	mock.lockListBuckets.RLock()
	calls = mock.calls.ListBuckets
	mock.lockListBuckets.RUnlock()
	return calls
}

// ListBucketsAndOwners calls ListBucketsAndOwnersFunc.
func (mock *BackendMock) ListBucketsAndOwners(contextMoqParam context.Context) ([]s3response.Bucket, error) {
	if mock.ListBucketsAndOwnersFunc == nil {
		panic("BackendMock.ListBucketsAndOwnersFunc: method is nil but Backend.ListBucketsAndOwners was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
	}{
		ContextMoqParam: contextMoqParam,
	}
	mock.lockListBucketsAndOwners.Lock()
	mock.calls.ListBucketsAndOwners = append(mock.calls.ListBucketsAndOwners, callInfo)
	mock.lockListBucketsAndOwners.Unlock()
	return mock.ListBucketsAndOwnersFunc(contextMoqParam)
}

// ListBucketsAndOwnersCalls gets all the calls that were made to ListBucketsAndOwners.
// Check the length with:
//
//	len(mockedBackend.ListBucketsAndOwnersCalls())
func (mock *BackendMock) ListBucketsAndOwnersCalls() []struct {
	ContextMoqParam context.Context
} {
	var calls []struct {
		ContextMoqParam context.Context
	}
	mock.lockListBucketsAndOwners.RLock()
	calls = mock.calls.ListBucketsAndOwners
	mock.lockListBucketsAndOwners.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
}

// ListObjectVersions calls ListObjectVersionsFunc.
func (mock *BackendMock) ListObjectVersions(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
	if mock.ListObjectVersionsFunc == nil {
		panic("BackendMock.ListObjectVersionsFunc: method is nil but Backend.ListObjectVersions was just called")
	}
	callInfo := struct {
		ContextMoqParam         context.Context
		ListObjectVersionsInput *s3.ListObjectVersionsInput
	}{
		ContextMoqParam:         contextMoqParam,
		ListObjectVersionsInput: listObjectVersionsInput,
	}
	mock.lockListObjectVersions.Lock()
	mock.calls.ListObjectVersions = append(mock.calls.ListObjectVersions, callInfo)
	mock.lockListObjectVersions.Unlock()
	return mock.ListObjectVersionsFunc(contextMoqParam, listObjectVersionsInput)
}

// ListObjectVersionsCalls gets all the calls that were made to ListObjectVersions.
// Check the length with:
//
//	len(mockedBackend.ListObjectVersionsCalls())
func (mock *BackendMock) ListObjectVersionsCalls() []struct {
	ContextMoqParam         context.Context
	ListObjectVersionsInput *s3.ListObjectVersionsInput
} {
	var calls []struct {
		ContextMoqParam         context.Context
		ListObjectVersionsInput *s3.ListObjectVersionsInput
	}
	mock.lockListObjectVersions.RLock()
	calls = mock.calls.ListObjectVersions
	mock.lockListObjectVersions.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
}

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

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

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

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

// PutBucketVersioning calls PutBucketVersioningFunc.
func (mock *BackendMock) PutBucketVersioning(contextMoqParam context.Context, putBucketVersioningInput *s3.PutBucketVersioningInput) error {
	if mock.PutBucketVersioningFunc == nil {
		panic("BackendMock.PutBucketVersioningFunc: method is nil but Backend.PutBucketVersioning was just called")
	}
	callInfo := struct {
		ContextMoqParam          context.Context
		PutBucketVersioningInput *s3.PutBucketVersioningInput
	}{
		ContextMoqParam:          contextMoqParam,
		PutBucketVersioningInput: putBucketVersioningInput,
	}
	mock.lockPutBucketVersioning.Lock()
	mock.calls.PutBucketVersioning = append(mock.calls.PutBucketVersioning, callInfo)
	mock.lockPutBucketVersioning.Unlock()
	return mock.PutBucketVersioningFunc(contextMoqParam, putBucketVersioningInput)
}

// PutBucketVersioningCalls gets all the calls that were made to PutBucketVersioning.
// Check the length with:
//
//	len(mockedBackend.PutBucketVersioningCalls())
func (mock *BackendMock) PutBucketVersioningCalls() []struct {
	ContextMoqParam          context.Context
	PutBucketVersioningInput *s3.PutBucketVersioningInput
} {
	var calls []struct {
		ContextMoqParam          context.Context
		PutBucketVersioningInput *s3.PutBucketVersioningInput
	}
	mock.lockPutBucketVersioning.RLock()
	calls = mock.calls.PutBucketVersioning
	mock.lockPutBucketVersioning.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
}

// PutObjectTagging calls PutObjectTaggingFunc.
func (mock *BackendMock) PutObjectTagging(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
	if mock.PutObjectTaggingFunc == nil {
		panic("BackendMock.PutObjectTaggingFunc: method is nil but Backend.PutObjectTagging 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.lockPutObjectTagging.Lock()
	mock.calls.PutObjectTagging = append(mock.calls.PutObjectTagging, callInfo)
	mock.lockPutObjectTagging.Unlock()
	return mock.PutObjectTaggingFunc(contextMoqParam, bucket, object, tags)
}

// PutObjectTaggingCalls gets all the calls that were made to PutObjectTagging.
// Check the length with:
//
//	len(mockedBackend.PutObjectTaggingCalls())
func (mock *BackendMock) PutObjectTaggingCalls() []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.lockPutObjectTagging.RLock()
	calls = mock.calls.PutObjectTagging
	mock.lockPutObjectTagging.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(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer) {
	if mock.SelectObjectContentFunc == nil {
		panic("BackendMock.SelectObjectContentFunc: method is nil but Backend.SelectObjectContent was just called")
	}
	callInfo := struct {
		Ctx   context.Context
		Input *s3.SelectObjectContentInput
	}{
		Ctx:   ctx,
		Input: input,
	}
	mock.lockSelectObjectContent.Lock()
	mock.calls.SelectObjectContent = append(mock.calls.SelectObjectContent, callInfo)
	mock.lockSelectObjectContent.Unlock()
	return mock.SelectObjectContentFunc(ctx, input)
}

// SelectObjectContentCalls gets all the calls that were made to SelectObjectContent.
// Check the length with:
//
//	len(mockedBackend.SelectObjectContentCalls())
func (mock *BackendMock) SelectObjectContentCalls() []struct {
	Ctx   context.Context
	Input *s3.SelectObjectContentInput
} {
	var calls []struct {
		Ctx   context.Context
		Input *s3.SelectObjectContentInput
	}
	mock.lockSelectObjectContent.RLock()
	calls = mock.calls.SelectObjectContent
	mock.lockSelectObjectContent.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
}