// Code generated by MockGen. DO NOT EDIT.
// Source: types.go
//
// Generated by this command:
//
//	mockgen -source=types.go -destination=RBDFactory_mockgen_mock.go -package=main
//

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

import (
	reflect "reflect"

	rbd "github.com/ceph/go-ceph/rbd"
	gomock "go.uber.org/mock/gomock"
)

// MockCephConnector is a mock of CephConnector interface.
type MockCephConnector struct {
	ctrl     *gomock.Controller
	recorder *MockCephConnectorMockRecorder
	isgomock struct{}
}

// MockCephConnectorMockRecorder is the mock recorder for MockCephConnector.
type MockCephConnectorMockRecorder struct {
	mock *MockCephConnector
}

// NewMockCephConnector creates a new mock instance.
func NewMockCephConnector(ctrl *gomock.Controller) *MockCephConnector {
	mock := &MockCephConnector{ctrl: ctrl}
	mock.recorder = &MockCephConnectorMockRecorder{mock}
	return mock
}

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

// ListPools mocks base method.
func (m *MockCephConnector) ListPools() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPools")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPools indicates an expected call of ListPools.
func (mr *MockCephConnectorMockRecorder) ListPools() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPools", reflect.TypeOf((*MockCephConnector)(nil).ListPools))
}

// OpenIOContext mocks base method.
func (m *MockCephConnector) OpenIOContext(poolName string) (IOContexter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenIOContext", poolName)
	ret0, _ := ret[0].(IOContexter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenIOContext indicates an expected call of OpenIOContext.
func (mr *MockCephConnectorMockRecorder) OpenIOContext(poolName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenIOContext", reflect.TypeOf((*MockCephConnector)(nil).OpenIOContext), poolName)
}

// MockIOContexter is a mock of IOContexter interface.
type MockIOContexter struct {
	ctrl     *gomock.Controller
	recorder *MockIOContexterMockRecorder
	isgomock struct{}
}

// MockIOContexterMockRecorder is the mock recorder for MockIOContexter.
type MockIOContexterMockRecorder struct {
	mock *MockIOContexter
}

// NewMockIOContexter creates a new mock instance.
func NewMockIOContexter(ctrl *gomock.Controller) *MockIOContexter {
	mock := &MockIOContexter{ctrl: ctrl}
	mock.recorder = &MockIOContexterMockRecorder{mock}
	return mock
}

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

// Destroy mocks base method.
func (m *MockIOContexter) Destroy() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Destroy")
}

// Destroy indicates an expected call of Destroy.
func (mr *MockIOContexterMockRecorder) Destroy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockIOContexter)(nil).Destroy))
}

// GetImage mocks base method.
func (m *MockIOContexter) GetImage(name string) RBDImager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImage", name)
	ret0, _ := ret[0].(RBDImager)
	return ret0
}

// GetImage indicates an expected call of GetImage.
func (mr *MockIOContexterMockRecorder) GetImage(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImage", reflect.TypeOf((*MockIOContexter)(nil).GetImage), name)
}

// GetImageNames mocks base method.
func (m *MockIOContexter) GetImageNames() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageNames")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageNames indicates an expected call of GetImageNames.
func (mr *MockIOContexterMockRecorder) GetImageNames() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageNames", reflect.TypeOf((*MockIOContexter)(nil).GetImageNames))
}

// MockRBDImager is a mock of RBDImager interface.
type MockRBDImager struct {
	ctrl     *gomock.Controller
	recorder *MockRBDImagerMockRecorder
	isgomock struct{}
}

// MockRBDImagerMockRecorder is the mock recorder for MockRBDImager.
type MockRBDImagerMockRecorder struct {
	mock *MockRBDImager
}

// NewMockRBDImager creates a new mock instance.
func NewMockRBDImager(ctrl *gomock.Controller) *MockRBDImager {
	mock := &MockRBDImager{ctrl: ctrl}
	mock.recorder = &MockRBDImagerMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockRBDImager) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockRBDImagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRBDImager)(nil).Close))
}

// Open mocks base method.
func (m *MockRBDImager) Open() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Open")
	ret0, _ := ret[0].(error)
	return ret0
}

// Open indicates an expected call of Open.
func (mr *MockRBDImagerMockRecorder) Open() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockRBDImager)(nil).Open))
}

// Stat mocks base method.
func (m *MockRBDImager) Stat() (*rbd.ImageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stat")
	ret0, _ := ret[0].(*rbd.ImageInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stat indicates an expected call of Stat.
func (mr *MockRBDImagerMockRecorder) Stat() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockRBDImager)(nil).Stat))
}

// MockiRBD is a mock of iRBD interface.
type MockiRBD struct {
	ctrl     *gomock.Controller
	recorder *MockiRBDMockRecorder
	isgomock struct{}
}

// MockiRBDMockRecorder is the mock recorder for MockiRBD.
type MockiRBDMockRecorder struct {
	mock *MockiRBD
}

// NewMockiRBD creates a new mock instance.
func NewMockiRBD(ctrl *gomock.Controller) *MockiRBD {
	mock := &MockiRBD{ctrl: ctrl}
	mock.recorder = &MockiRBDMockRecorder{mock}
	return mock
}

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

// getName mocks base method.
func (m *MockiRBD) getName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "getName")
	ret0, _ := ret[0].(string)
	return ret0
}

// getName indicates an expected call of getName.
func (mr *MockiRBDMockRecorder) getName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getName", reflect.TypeOf((*MockiRBD)(nil).getName))
}

// getSize mocks base method.
func (m *MockiRBD) getSize() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "getSize")
	ret0, _ := ret[0].(int64)
	return ret0
}

// getSize indicates an expected call of getSize.
func (mr *MockiRBDMockRecorder) getSize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getSize", reflect.TypeOf((*MockiRBD)(nil).getSize))
}