// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go

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

import (
	os "os"
	filepath "path/filepath"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockfileSystem is a mock of fileSystem interface.
type MockfileSystem struct {
	ctrl     *gomock.Controller
	recorder *MockfileSystemMockRecorder
}

// MockfileSystemMockRecorder is the mock recorder for MockfileSystem.
type MockfileSystemMockRecorder struct {
	mock *MockfileSystem
}

// NewMockfileSystem creates a new mock instance.
func NewMockfileSystem(ctrl *gomock.Controller) *MockfileSystem {
	mock := &MockfileSystem{ctrl: ctrl}
	mock.recorder = &MockfileSystemMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Walk mocks base method.
func (m *MockfileSystem) Walk(root string, walkFn filepath.WalkFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Walk", root, walkFn)
	ret0, _ := ret[0].(error)
	return ret0
}

// Walk indicates an expected call of Walk.
func (mr *MockfileSystemMockRecorder) Walk(root, walkFn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Walk", reflect.TypeOf((*MockfileSystem)(nil).Walk), root, walkFn)
}

// MockglobCompiler is a mock of globCompiler interface.
type MockglobCompiler struct {
	ctrl     *gomock.Controller
	recorder *MockglobCompilerMockRecorder
}

// MockglobCompilerMockRecorder is the mock recorder for MockglobCompiler.
type MockglobCompilerMockRecorder struct {
	mock *MockglobCompiler
}

// NewMockglobCompiler creates a new mock instance.
func NewMockglobCompiler(ctrl *gomock.Controller) *MockglobCompiler {
	mock := &MockglobCompiler{ctrl: ctrl}
	mock.recorder = &MockglobCompilerMockRecorder{mock}
	return mock
}

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

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

// Compile indicates an expected call of Compile.
func (mr *MockglobCompilerMockRecorder) Compile(pattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compile", reflect.TypeOf((*MockglobCompiler)(nil).Compile), pattern)
}

// MockcompiledGlob is a mock of compiledGlob interface.
type MockcompiledGlob struct {
	ctrl     *gomock.Controller
	recorder *MockcompiledGlobMockRecorder
}

// MockcompiledGlobMockRecorder is the mock recorder for MockcompiledGlob.
type MockcompiledGlobMockRecorder struct {
	mock *MockcompiledGlob
}

// NewMockcompiledGlob creates a new mock instance.
func NewMockcompiledGlob(ctrl *gomock.Controller) *MockcompiledGlob {
	mock := &MockcompiledGlob{ctrl: ctrl}
	mock.recorder = &MockcompiledGlobMockRecorder{mock}
	return mock
}

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

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

// Match indicates an expected call of Match.
func (mr *MockcompiledGlobMockRecorder) Match(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Match", reflect.TypeOf((*MockcompiledGlob)(nil).Match), arg0)
}

// MockFileMatcherInterface is a mock of FileMatcherInterface interface.
type MockFileMatcherInterface struct {
	ctrl     *gomock.Controller
	recorder *MockFileMatcherInterfaceMockRecorder
}

// MockFileMatcherInterfaceMockRecorder is the mock recorder for MockFileMatcherInterface.
type MockFileMatcherInterfaceMockRecorder struct {
	mock *MockFileMatcherInterface
}

// NewMockFileMatcherInterface creates a new mock instance.
func NewMockFileMatcherInterface(ctrl *gomock.Controller) *MockFileMatcherInterface {
	mock := &MockFileMatcherInterface{ctrl: ctrl}
	mock.recorder = &MockFileMatcherInterfaceMockRecorder{mock}
	return mock
}

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

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

// MatchFiles indicates an expected call of MatchFiles.
func (mr *MockFileMatcherInterfaceMockRecorder) MatchFiles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchFiles", reflect.TypeOf((*MockFileMatcherInterface)(nil).MatchFiles), arg0)
}
