storj/pkg/miniogw/logging/objlayer_mock_test.go

// Copyright (C) 2018 Storj Labs, Inc.
// See LICENSE for copying information.

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/minio/minio/cmd (interfaces: ObjectLayer)

// Package logging is a generated GoMock package.
package logging

import (
	context "context"
	io "io"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	cmd "github.com/minio/minio/cmd"
	hash "github.com/minio/minio/pkg/hash"
	madmin "github.com/minio/minio/pkg/madmin"
	policy "github.com/minio/minio/pkg/policy"
)

// MockObjectLayer is a mock of ObjectLayer interface
type MockObjectLayer struct {
	ctrl     *gomock.Controller
	recorder *MockObjectLayerMockRecorder
}

// MockObjectLayerMockRecorder is the mock recorder for MockObjectLayer
type MockObjectLayerMockRecorder struct {
	mock *MockObjectLayer
}

// NewMockObjectLayer creates a new mock instance
func NewMockObjectLayer(ctrl *gomock.Controller) *MockObjectLayer {
	mock := &MockObjectLayer{ctrl: ctrl}
	mock.recorder = &MockObjectLayerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockObjectLayer) EXPECT() *MockObjectLayerMockRecorder {
	return m.recorder
}

// AbortMultipartUpload mocks base method
func (m *MockObjectLayer) AbortMultipartUpload(arg0 context.Context, arg1, arg2, arg3 string) error {
	ret := m.ctrl.Call(m, "AbortMultipartUpload", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// AbortMultipartUpload indicates an expected call of AbortMultipartUpload
func (mr *MockObjectLayerMockRecorder) AbortMultipartUpload(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).AbortMultipartUpload), arg0, arg1, arg2, arg3)
}

// ClearLocks mocks base method
func (m *MockObjectLayer) ClearLocks(arg0 context.Context, arg1 []cmd.VolumeLockInfo) error {
	ret := m.ctrl.Call(m, "ClearLocks", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ClearLocks indicates an expected call of ClearLocks
func (mr *MockObjectLayerMockRecorder) ClearLocks(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLocks", reflect.TypeOf((*MockObjectLayer)(nil).ClearLocks), arg0, arg1)
}

// CompleteMultipartUpload mocks base method
func (m *MockObjectLayer) CompleteMultipartUpload(arg0 context.Context, arg1, arg2, arg3 string, arg4 []cmd.CompletePart) (cmd.ObjectInfo, error) {
	ret := m.ctrl.Call(m, "CompleteMultipartUpload", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(cmd.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteMultipartUpload indicates an expected call of CompleteMultipartUpload
func (mr *MockObjectLayerMockRecorder) CompleteMultipartUpload(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).CompleteMultipartUpload), arg0, arg1, arg2, arg3, arg4)
}

// CopyObject mocks base method
func (m *MockObjectLayer) CopyObject(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 cmd.ObjectInfo) (cmd.ObjectInfo, error) {
	ret := m.ctrl.Call(m, "CopyObject", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(cmd.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyObject indicates an expected call of CopyObject
func (mr *MockObjectLayerMockRecorder) CopyObject(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObject", reflect.TypeOf((*MockObjectLayer)(nil).CopyObject), arg0, arg1, arg2, arg3, arg4, arg5)
}

// CopyObjectPart mocks base method
func (m *MockObjectLayer) CopyObjectPart(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6 int, arg7, arg8 int64, arg9 cmd.ObjectInfo) (cmd.PartInfo, error) {
	ret := m.ctrl.Call(m, "CopyObjectPart", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
	ret0, _ := ret[0].(cmd.PartInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyObjectPart indicates an expected call of CopyObjectPart
func (mr *MockObjectLayerMockRecorder) CopyObjectPart(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectPart", reflect.TypeOf((*MockObjectLayer)(nil).CopyObjectPart), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
}

// DeleteBucket mocks base method
func (m *MockObjectLayer) DeleteBucket(arg0 context.Context, arg1 string) error {
	ret := m.ctrl.Call(m, "DeleteBucket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBucket indicates an expected call of DeleteBucket
func (mr *MockObjectLayerMockRecorder) DeleteBucket(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockObjectLayer)(nil).DeleteBucket), arg0, arg1)
}

// DeleteBucketPolicy mocks base method
func (m *MockObjectLayer) DeleteBucketPolicy(arg0 context.Context, arg1 string) error {
	ret := m.ctrl.Call(m, "DeleteBucketPolicy", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBucketPolicy indicates an expected call of DeleteBucketPolicy
func (mr *MockObjectLayerMockRecorder) DeleteBucketPolicy(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).DeleteBucketPolicy), arg0, arg1)
}

// DeleteObject mocks base method
func (m *MockObjectLayer) DeleteObject(arg0 context.Context, arg1, arg2 string) error {
	ret := m.ctrl.Call(m, "DeleteObject", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteObject indicates an expected call of DeleteObject
func (mr *MockObjectLayerMockRecorder) DeleteObject(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockObjectLayer)(nil).DeleteObject), arg0, arg1, arg2)
}

// GetBucketInfo mocks base method
func (m *MockObjectLayer) GetBucketInfo(arg0 context.Context, arg1 string) (cmd.BucketInfo, error) {
	ret := m.ctrl.Call(m, "GetBucketInfo", arg0, arg1)
	ret0, _ := ret[0].(cmd.BucketInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketInfo indicates an expected call of GetBucketInfo
func (mr *MockObjectLayerMockRecorder) GetBucketInfo(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInfo", reflect.TypeOf((*MockObjectLayer)(nil).GetBucketInfo), arg0, arg1)
}

// GetBucketPolicy mocks base method
func (m *MockObjectLayer) GetBucketPolicy(arg0 context.Context, arg1 string) (*policy.Policy, error) {
	ret := m.ctrl.Call(m, "GetBucketPolicy", arg0, arg1)
	ret0, _ := ret[0].(*policy.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucketPolicy indicates an expected call of GetBucketPolicy
func (mr *MockObjectLayerMockRecorder) GetBucketPolicy(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).GetBucketPolicy), arg0, arg1)
}

// GetObject mocks base method
func (m *MockObjectLayer) GetObject(arg0 context.Context, arg1, arg2 string, arg3, arg4 int64, arg5 io.Writer, arg6 string) error {
	ret := m.ctrl.Call(m, "GetObject", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetObject indicates an expected call of GetObject
func (mr *MockObjectLayerMockRecorder) GetObject(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockObjectLayer)(nil).GetObject), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// GetObjectInfo mocks base method
func (m *MockObjectLayer) GetObjectInfo(arg0 context.Context, arg1, arg2 string) (cmd.ObjectInfo, error) {
	ret := m.ctrl.Call(m, "GetObjectInfo", arg0, arg1, arg2)
	ret0, _ := ret[0].(cmd.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectInfo indicates an expected call of GetObjectInfo
func (mr *MockObjectLayerMockRecorder) GetObjectInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectInfo", reflect.TypeOf((*MockObjectLayer)(nil).GetObjectInfo), arg0, arg1, arg2)
}

// HealBucket mocks base method
func (m *MockObjectLayer) HealBucket(arg0 context.Context, arg1 string, arg2 bool) ([]madmin.HealResultItem, error) {
	ret := m.ctrl.Call(m, "HealBucket", arg0, arg1, arg2)
	ret0, _ := ret[0].([]madmin.HealResultItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HealBucket indicates an expected call of HealBucket
func (mr *MockObjectLayerMockRecorder) HealBucket(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealBucket", reflect.TypeOf((*MockObjectLayer)(nil).HealBucket), arg0, arg1, arg2)
}

// HealFormat mocks base method
func (m *MockObjectLayer) HealFormat(arg0 context.Context, arg1 bool) (madmin.HealResultItem, error) {
	ret := m.ctrl.Call(m, "HealFormat", arg0, arg1)
	ret0, _ := ret[0].(madmin.HealResultItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HealFormat indicates an expected call of HealFormat
func (mr *MockObjectLayerMockRecorder) HealFormat(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealFormat", reflect.TypeOf((*MockObjectLayer)(nil).HealFormat), arg0, arg1)
}

// HealObject mocks base method
func (m *MockObjectLayer) HealObject(arg0 context.Context, arg1, arg2 string, arg3 bool) (madmin.HealResultItem, error) {
	ret := m.ctrl.Call(m, "HealObject", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(madmin.HealResultItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HealObject indicates an expected call of HealObject
func (mr *MockObjectLayerMockRecorder) HealObject(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealObject", reflect.TypeOf((*MockObjectLayer)(nil).HealObject), arg0, arg1, arg2, arg3)
}

// IsEncryptionSupported mocks base method
func (m *MockObjectLayer) IsEncryptionSupported() bool {
	ret := m.ctrl.Call(m, "IsEncryptionSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsEncryptionSupported indicates an expected call of IsEncryptionSupported
func (mr *MockObjectLayerMockRecorder) IsEncryptionSupported() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEncryptionSupported", reflect.TypeOf((*MockObjectLayer)(nil).IsEncryptionSupported))
}

// IsNotificationSupported mocks base method
func (m *MockObjectLayer) IsNotificationSupported() bool {
	ret := m.ctrl.Call(m, "IsNotificationSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNotificationSupported indicates an expected call of IsNotificationSupported
func (mr *MockObjectLayerMockRecorder) IsNotificationSupported() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotificationSupported", reflect.TypeOf((*MockObjectLayer)(nil).IsNotificationSupported))
}

// ListBuckets mocks base method
func (m *MockObjectLayer) ListBuckets(arg0 context.Context) ([]cmd.BucketInfo, error) {
	ret := m.ctrl.Call(m, "ListBuckets", arg0)
	ret0, _ := ret[0].([]cmd.BucketInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBuckets indicates an expected call of ListBuckets
func (mr *MockObjectLayerMockRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockObjectLayer)(nil).ListBuckets), arg0)
}

// ListBucketsHeal mocks base method
func (m *MockObjectLayer) ListBucketsHeal(arg0 context.Context) ([]cmd.BucketInfo, error) {
	ret := m.ctrl.Call(m, "ListBucketsHeal", arg0)
	ret0, _ := ret[0].([]cmd.BucketInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBucketsHeal indicates an expected call of ListBucketsHeal
func (mr *MockObjectLayerMockRecorder) ListBucketsHeal(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsHeal", reflect.TypeOf((*MockObjectLayer)(nil).ListBucketsHeal), arg0)
}

// ListLocks mocks base method
func (m *MockObjectLayer) ListLocks(arg0 context.Context, arg1, arg2 string, arg3 time.Duration) ([]cmd.VolumeLockInfo, error) {
	ret := m.ctrl.Call(m, "ListLocks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]cmd.VolumeLockInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLocks indicates an expected call of ListLocks
func (mr *MockObjectLayerMockRecorder) ListLocks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocks", reflect.TypeOf((*MockObjectLayer)(nil).ListLocks), arg0, arg1, arg2, arg3)
}

// ListMultipartUploads mocks base method
func (m *MockObjectLayer) ListMultipartUploads(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6 int) (cmd.ListMultipartsInfo, error) {
	ret := m.ctrl.Call(m, "ListMultipartUploads", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(cmd.ListMultipartsInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMultipartUploads indicates an expected call of ListMultipartUploads
func (mr *MockObjectLayerMockRecorder) ListMultipartUploads(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploads", reflect.TypeOf((*MockObjectLayer)(nil).ListMultipartUploads), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// ListObjectParts mocks base method
func (m *MockObjectLayer) ListObjectParts(arg0 context.Context, arg1, arg2, arg3 string, arg4, arg5 int) (cmd.ListPartsInfo, error) {
	ret := m.ctrl.Call(m, "ListObjectParts", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(cmd.ListPartsInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectParts indicates an expected call of ListObjectParts
func (mr *MockObjectLayerMockRecorder) ListObjectParts(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectParts", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectParts), arg0, arg1, arg2, arg3, arg4, arg5)
}

// ListObjects mocks base method
func (m *MockObjectLayer) ListObjects(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int) (cmd.ListObjectsInfo, error) {
	ret := m.ctrl.Call(m, "ListObjects", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(cmd.ListObjectsInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjects indicates an expected call of ListObjects
func (mr *MockObjectLayerMockRecorder) ListObjects(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*MockObjectLayer)(nil).ListObjects), arg0, arg1, arg2, arg3, arg4, arg5)
}

// ListObjectsHeal mocks base method
func (m *MockObjectLayer) ListObjectsHeal(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int) (cmd.ListObjectsInfo, error) {
	ret := m.ctrl.Call(m, "ListObjectsHeal", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(cmd.ListObjectsInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsHeal indicates an expected call of ListObjectsHeal
func (mr *MockObjectLayerMockRecorder) ListObjectsHeal(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsHeal", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectsHeal), arg0, arg1, arg2, arg3, arg4, arg5)
}

// ListObjectsV2 mocks base method
func (m *MockObjectLayer) ListObjectsV2(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int, arg6 bool, arg7 string) (cmd.ListObjectsV2Info, error) {
	ret := m.ctrl.Call(m, "ListObjectsV2", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	ret0, _ := ret[0].(cmd.ListObjectsV2Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsV2 indicates an expected call of ListObjectsV2
func (mr *MockObjectLayerMockRecorder) ListObjectsV2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectsV2), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
}

// MakeBucketWithLocation mocks base method
func (m *MockObjectLayer) MakeBucketWithLocation(arg0 context.Context, arg1, arg2 string) error {
	ret := m.ctrl.Call(m, "MakeBucketWithLocation", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// MakeBucketWithLocation indicates an expected call of MakeBucketWithLocation
func (mr *MockObjectLayerMockRecorder) MakeBucketWithLocation(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeBucketWithLocation", reflect.TypeOf((*MockObjectLayer)(nil).MakeBucketWithLocation), arg0, arg1, arg2)
}

// NewMultipartUpload mocks base method
func (m *MockObjectLayer) NewMultipartUpload(arg0 context.Context, arg1, arg2 string, arg3 map[string]string) (string, error) {
	ret := m.ctrl.Call(m, "NewMultipartUpload", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewMultipartUpload indicates an expected call of NewMultipartUpload
func (mr *MockObjectLayerMockRecorder) NewMultipartUpload(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).NewMultipartUpload), arg0, arg1, arg2, arg3)
}

// PutObject mocks base method
func (m *MockObjectLayer) PutObject(arg0 context.Context, arg1, arg2 string, arg3 *hash.Reader, arg4 map[string]string) (cmd.ObjectInfo, error) {
	ret := m.ctrl.Call(m, "PutObject", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(cmd.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObject indicates an expected call of PutObject
func (mr *MockObjectLayerMockRecorder) PutObject(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockObjectLayer)(nil).PutObject), arg0, arg1, arg2, arg3, arg4)
}

// PutObjectPart mocks base method
func (m *MockObjectLayer) PutObjectPart(arg0 context.Context, arg1, arg2, arg3 string, arg4 int, arg5 *hash.Reader) (cmd.PartInfo, error) {
	ret := m.ctrl.Call(m, "PutObjectPart", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(cmd.PartInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObjectPart indicates an expected call of PutObjectPart
func (mr *MockObjectLayerMockRecorder) PutObjectPart(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectPart", reflect.TypeOf((*MockObjectLayer)(nil).PutObjectPart), arg0, arg1, arg2, arg3, arg4, arg5)
}

// ReloadFormat mocks base method
func (m *MockObjectLayer) ReloadFormat(arg0 context.Context, arg1 bool) error {
	ret := m.ctrl.Call(m, "ReloadFormat", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReloadFormat indicates an expected call of ReloadFormat
func (mr *MockObjectLayerMockRecorder) ReloadFormat(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadFormat", reflect.TypeOf((*MockObjectLayer)(nil).ReloadFormat), arg0, arg1)
}

// SetBucketPolicy mocks base method
func (m *MockObjectLayer) SetBucketPolicy(arg0 context.Context, arg1 string, arg2 *policy.Policy) error {
	ret := m.ctrl.Call(m, "SetBucketPolicy", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetBucketPolicy indicates an expected call of SetBucketPolicy
func (mr *MockObjectLayerMockRecorder) SetBucketPolicy(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).SetBucketPolicy), arg0, arg1, arg2)
}

// Shutdown mocks base method
func (m *MockObjectLayer) Shutdown(arg0 context.Context) error {
	ret := m.ctrl.Call(m, "Shutdown", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Shutdown indicates an expected call of Shutdown
func (mr *MockObjectLayerMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockObjectLayer)(nil).Shutdown), arg0)
}

// StorageInfo mocks base method
func (m *MockObjectLayer) StorageInfo(arg0 context.Context) cmd.StorageInfo {
	ret := m.ctrl.Call(m, "StorageInfo", arg0)
	ret0, _ := ret[0].(cmd.StorageInfo)
	return ret0
}

// StorageInfo indicates an expected call of StorageInfo
func (mr *MockObjectLayerMockRecorder) StorageInfo(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageInfo", reflect.TypeOf((*MockObjectLayer)(nil).StorageInfo), arg0)
}