// Code generated by MockGen. DO NOT EDIT.
// Source: commands/mllint/interfaces.go

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

import (
	api "github.com/bvobart/mllint/api"
	mllint "github.com/bvobart/mllint/commands/mllint"
	config "github.com/bvobart/mllint/config"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockRunner is a mock of Runner interface
type MockRunner struct {
	ctrl     *gomock.Controller
	recorder *MockRunnerMockRecorder
}

// MockRunnerMockRecorder is the mock recorder for MockRunner
type MockRunnerMockRecorder struct {
	mock *MockRunner
}

// NewMockRunner creates a new mock instance
func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
	mock := &MockRunner{ctrl: ctrl}
	mock.recorder = &MockRunnerMockRecorder{mock}
	return mock
}

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

// RunLinter mocks base method
func (m *MockRunner) RunLinter(id string, linter api.Linter, project api.Project, options ...mllint.TaskOption) *mllint.RunnerTask {
	m.ctrl.T.Helper()
	varargs := []interface{}{id, linter, project}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunLinter", varargs...)
	ret0, _ := ret[0].(*mllint.RunnerTask)
	return ret0
}

// RunLinter indicates an expected call of RunLinter
func (mr *MockRunnerMockRecorder) RunLinter(id, linter, project interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id, linter, project}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunLinter", reflect.TypeOf((*MockRunner)(nil).RunLinter), varargs...)
}

// CollectTasks mocks base method
func (m *MockRunner) CollectTasks(tasks ...*mllint.RunnerTask) chan *mllint.RunnerTask {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range tasks {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CollectTasks", varargs...)
	ret0, _ := ret[0].(chan *mllint.RunnerTask)
	return ret0
}

// CollectTasks indicates an expected call of CollectTasks
func (mr *MockRunnerMockRecorder) CollectTasks(tasks ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectTasks", reflect.TypeOf((*MockRunner)(nil).CollectTasks), tasks...)
}

// MockWithRunner is a mock of WithRunner interface
type MockWithRunner struct {
	ctrl     *gomock.Controller
	recorder *MockWithRunnerMockRecorder
}

// MockWithRunnerMockRecorder is the mock recorder for MockWithRunner
type MockWithRunnerMockRecorder struct {
	mock *MockWithRunner
}

// NewMockWithRunner creates a new mock instance
func NewMockWithRunner(ctrl *gomock.Controller) *MockWithRunner {
	mock := &MockWithRunner{ctrl: ctrl}
	mock.recorder = &MockWithRunnerMockRecorder{mock}
	return mock
}

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

// SetRunner mocks base method
func (m *MockWithRunner) SetRunner(runner mllint.Runner) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRunner", runner)
}

// SetRunner indicates an expected call of SetRunner
func (mr *MockWithRunnerMockRecorder) SetRunner(runner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRunner", reflect.TypeOf((*MockWithRunner)(nil).SetRunner), runner)
}

// MockLinterWithRunner is a mock of LinterWithRunner interface
type MockLinterWithRunner struct {
	ctrl     *gomock.Controller
	recorder *MockLinterWithRunnerMockRecorder
}

// MockLinterWithRunnerMockRecorder is the mock recorder for MockLinterWithRunner
type MockLinterWithRunnerMockRecorder struct {
	mock *MockLinterWithRunner
}

// NewMockLinterWithRunner creates a new mock instance
func NewMockLinterWithRunner(ctrl *gomock.Controller) *MockLinterWithRunner {
	mock := &MockLinterWithRunner{ctrl: ctrl}
	mock.recorder = &MockLinterWithRunnerMockRecorder{mock}
	return mock
}

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

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

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

// Rules mocks base method
func (m *MockLinterWithRunner) Rules() []*api.Rule {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rules")
	ret0, _ := ret[0].([]*api.Rule)
	return ret0
}

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

// LintProject mocks base method
func (m *MockLinterWithRunner) LintProject(project api.Project) (api.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LintProject", project)
	ret0, _ := ret[0].(api.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LintProject indicates an expected call of LintProject
func (mr *MockLinterWithRunnerMockRecorder) LintProject(project interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LintProject", reflect.TypeOf((*MockLinterWithRunner)(nil).LintProject), project)
}

// SetRunner mocks base method
func (m *MockLinterWithRunner) SetRunner(runner mllint.Runner) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRunner", runner)
}

// SetRunner indicates an expected call of SetRunner
func (mr *MockLinterWithRunnerMockRecorder) SetRunner(runner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRunner", reflect.TypeOf((*MockLinterWithRunner)(nil).SetRunner), runner)
}

// MockConfigurableLinterWithRunner is a mock of ConfigurableLinterWithRunner interface
type MockConfigurableLinterWithRunner struct {
	ctrl     *gomock.Controller
	recorder *MockConfigurableLinterWithRunnerMockRecorder
}

// MockConfigurableLinterWithRunnerMockRecorder is the mock recorder for MockConfigurableLinterWithRunner
type MockConfigurableLinterWithRunnerMockRecorder struct {
	mock *MockConfigurableLinterWithRunner
}

// NewMockConfigurableLinterWithRunner creates a new mock instance
func NewMockConfigurableLinterWithRunner(ctrl *gomock.Controller) *MockConfigurableLinterWithRunner {
	mock := &MockConfigurableLinterWithRunner{ctrl: ctrl}
	mock.recorder = &MockConfigurableLinterWithRunnerMockRecorder{mock}
	return mock
}

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

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

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

// Rules mocks base method
func (m *MockConfigurableLinterWithRunner) Rules() []*api.Rule {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rules")
	ret0, _ := ret[0].([]*api.Rule)
	return ret0
}

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

// LintProject mocks base method
func (m *MockConfigurableLinterWithRunner) LintProject(project api.Project) (api.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LintProject", project)
	ret0, _ := ret[0].(api.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LintProject indicates an expected call of LintProject
func (mr *MockConfigurableLinterWithRunnerMockRecorder) LintProject(project interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LintProject", reflect.TypeOf((*MockConfigurableLinterWithRunner)(nil).LintProject), project)
}

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

// Configure indicates an expected call of Configure
func (mr *MockConfigurableLinterWithRunnerMockRecorder) Configure(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Configure", reflect.TypeOf((*MockConfigurableLinterWithRunner)(nil).Configure), conf)
}

// SetRunner mocks base method
func (m *MockConfigurableLinterWithRunner) SetRunner(runner mllint.Runner) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRunner", runner)
}

// SetRunner indicates an expected call of SetRunner
func (mr *MockConfigurableLinterWithRunnerMockRecorder) SetRunner(runner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRunner", reflect.TypeOf((*MockConfigurableLinterWithRunner)(nil).SetRunner), runner)
}
