stage_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./stage_interface.go
//
// Generated by this command:
//
//	mockgen -source=./stage_interface.go -package=gone -destination=stage_mock.go
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockInitiator is a mock of Initiator interface.
type MockInitiator struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockInitiatorMockRecorder
	isgomock struct{}
}

// MockInitiatorMockRecorder is the mock recorder for MockInitiator.
type MockInitiatorMockRecorder struct {
	mock *MockInitiator
}

// NewMockInitiator creates a new mock instance.
func NewMockInitiator(ctrl *gomock.Controller) *MockInitiator {
	mock := &MockInitiator{ctrl: ctrl}
	mock.recorder = &MockInitiatorMockRecorder{mock}
	return mock
}

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

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

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

// MockInitiatorNoError is a mock of InitiatorNoError interface.
type MockInitiatorNoError struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockInitiatorNoErrorMockRecorder
	isgomock struct{}
}

// MockInitiatorNoErrorMockRecorder is the mock recorder for MockInitiatorNoError.
type MockInitiatorNoErrorMockRecorder struct {
	mock *MockInitiatorNoError
}

// NewMockInitiatorNoError creates a new mock instance.
func NewMockInitiatorNoError(ctrl *gomock.Controller) *MockInitiatorNoError {
	mock := &MockInitiatorNoError{ctrl: ctrl}
	mock.recorder = &MockInitiatorNoErrorMockRecorder{mock}
	return mock
}

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

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

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

// MockBeforeInitiator is a mock of BeforeInitiator interface.
type MockBeforeInitiator struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockBeforeInitiatorMockRecorder
	isgomock struct{}
}

// MockBeforeInitiatorMockRecorder is the mock recorder for MockBeforeInitiator.
type MockBeforeInitiatorMockRecorder struct {
	mock *MockBeforeInitiator
}

// NewMockBeforeInitiator creates a new mock instance.
func NewMockBeforeInitiator(ctrl *gomock.Controller) *MockBeforeInitiator {
	mock := &MockBeforeInitiator{ctrl: ctrl}
	mock.recorder = &MockBeforeInitiatorMockRecorder{mock}
	return mock
}

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

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

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

// MockBeforeInitiatorNoError is a mock of BeforeInitiatorNoError interface.
type MockBeforeInitiatorNoError struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockBeforeInitiatorNoErrorMockRecorder
	isgomock struct{}
}

// MockBeforeInitiatorNoErrorMockRecorder is the mock recorder for MockBeforeInitiatorNoError.
type MockBeforeInitiatorNoErrorMockRecorder struct {
	mock *MockBeforeInitiatorNoError
}

// NewMockBeforeInitiatorNoError creates a new mock instance.
func NewMockBeforeInitiatorNoError(ctrl *gomock.Controller) *MockBeforeInitiatorNoError {
	mock := &MockBeforeInitiatorNoError{ctrl: ctrl}
	mock.recorder = &MockBeforeInitiatorNoErrorMockRecorder{mock}
	return mock
}

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

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

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

// MockBeforeStarter is a mock of BeforeStarter interface.
type MockBeforeStarter struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockBeforeStarterMockRecorder
	isgomock struct{}
}

// MockBeforeStarterMockRecorder is the mock recorder for MockBeforeStarter.
type MockBeforeStarterMockRecorder struct {
	mock *MockBeforeStarter
}

// NewMockBeforeStarter creates a new mock instance.
func NewMockBeforeStarter(ctrl *gomock.Controller) *MockBeforeStarter {
	mock := &MockBeforeStarter{ctrl: ctrl}
	mock.recorder = &MockBeforeStarterMockRecorder{mock}
	return mock
}

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

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

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

// MockAfterStarter is a mock of AfterStarter interface.
type MockAfterStarter struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockAfterStarterMockRecorder
	isgomock struct{}
}

// MockAfterStarterMockRecorder is the mock recorder for MockAfterStarter.
type MockAfterStarterMockRecorder struct {
	mock *MockAfterStarter
}

// NewMockAfterStarter creates a new mock instance.
func NewMockAfterStarter(ctrl *gomock.Controller) *MockAfterStarter {
	mock := &MockAfterStarter{ctrl: ctrl}
	mock.recorder = &MockAfterStarterMockRecorder{mock}
	return mock
}

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

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

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

// MockBeforeStoper is a mock of BeforeStoper interface.
type MockBeforeStoper struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockBeforeStoperMockRecorder
	isgomock struct{}
}

// MockBeforeStoperMockRecorder is the mock recorder for MockBeforeStoper.
type MockBeforeStoperMockRecorder struct {
	mock *MockBeforeStoper
}

// NewMockBeforeStoper creates a new mock instance.
func NewMockBeforeStoper(ctrl *gomock.Controller) *MockBeforeStoper {
	mock := &MockBeforeStoper{ctrl: ctrl}
	mock.recorder = &MockBeforeStoperMockRecorder{mock}
	return mock
}

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

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

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

// MockAfterStoper is a mock of AfterStoper interface.
type MockAfterStoper struct {
	Flag
	ctrl     *gomock.Controller
	recorder *MockAfterStoperMockRecorder
	isgomock struct{}
}

// MockAfterStoperMockRecorder is the mock recorder for MockAfterStoper.
type MockAfterStoperMockRecorder struct {
	mock *MockAfterStoper
}

// NewMockAfterStoper creates a new mock instance.
func NewMockAfterStoper(ctrl *gomock.Controller) *MockAfterStoper {
	mock := &MockAfterStoper{ctrl: ctrl}
	mock.recorder = &MockAfterStoperMockRecorder{mock}
	return mock
}

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

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

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