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

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

import (
	mytypes "rbd_exporter/mytypes"
	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) (mytypes.IOContexter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenIOContext", poolName)
	ret0, _ := ret[0].(mytypes.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) mytypes.RBDImager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImage", name)
	ret0, _ := ret[0].(mytypes.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))
}
