// Code generated by MockGen. DO NOT EDIT.
// Source: worker_interface.go
//
// Generated by this command:
//
//	mockgen -source worker_interface.go -destination worker_mock.go -package worker github.com/uber/cadence/service/worker/worker Worker
//

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

import (
	reflect "reflect"

	activity "go.uber.org/cadence/activity"
	workflow "go.uber.org/cadence/workflow"
	gomock "go.uber.org/mock/gomock"
)

// MockWorker is a mock of Worker interface.
type MockWorker struct {
	ctrl     *gomock.Controller
	recorder *MockWorkerMockRecorder
	isgomock struct{}
}

// MockWorkerMockRecorder is the mock recorder for MockWorker.
type MockWorkerMockRecorder struct {
	mock *MockWorker
}

// NewMockWorker creates a new mock instance.
func NewMockWorker(ctrl *gomock.Controller) *MockWorker {
	mock := &MockWorker{ctrl: ctrl}
	mock.recorder = &MockWorkerMockRecorder{mock}
	return mock
}

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

// RegisterActivity mocks base method.
func (m *MockWorker) RegisterActivity(activity any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterActivity", activity)
}

// RegisterActivity indicates an expected call of RegisterActivity.
func (mr *MockWorkerMockRecorder) RegisterActivity(activity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivity", reflect.TypeOf((*MockWorker)(nil).RegisterActivity), activity)
}

// RegisterActivityWithOptions mocks base method.
func (m *MockWorker) RegisterActivityWithOptions(activity any, options activity.RegisterOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterActivityWithOptions", activity, options)
}

// RegisterActivityWithOptions indicates an expected call of RegisterActivityWithOptions.
func (mr *MockWorkerMockRecorder) RegisterActivityWithOptions(activity, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivityWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterActivityWithOptions), activity, options)
}

// RegisterWorkflow mocks base method.
func (m *MockWorker) RegisterWorkflow(workflow any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterWorkflow", workflow)
}

// RegisterWorkflow indicates an expected call of RegisterWorkflow.
func (mr *MockWorkerMockRecorder) RegisterWorkflow(workflow any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflow", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflow), workflow)
}

// RegisterWorkflowWithOptions mocks base method.
func (m *MockWorker) RegisterWorkflowWithOptions(workflow any, options workflow.RegisterOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterWorkflowWithOptions", workflow, options)
}

// RegisterWorkflowWithOptions indicates an expected call of RegisterWorkflowWithOptions.
func (mr *MockWorkerMockRecorder) RegisterWorkflowWithOptions(workflow, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflowWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflowWithOptions), workflow, options)
}

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

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

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

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

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

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