fs_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/dbnode/persist/fs (interfaces: DataFileSetWriter,DataFileSetReader,DataFileSetSeeker,IndexFileSetWriter,IndexFileSetReader,IndexSegmentFileSetWriter,IndexSegmentFileSet,IndexSegmentFile,SnapshotMetadataFileWriter,DataFileSetSeekerManager,ConcurrentDataFileSetSeeker,MergeWith)

// Copyright (c) 2019 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

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

import (
	"io"
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/namespace"
	"github.com/m3db/m3/src/dbnode/x/xio"
	"github.com/m3db/m3/src/m3ninx/persist"
	"github.com/m3db/m3/src/x/checked"
	"github.com/m3db/m3/src/x/context"
	"github.com/m3db/m3/src/x/ident"
	time0 "github.com/m3db/m3/src/x/time"

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

// MockDataFileSetWriter is a mock of DataFileSetWriter interface
type MockDataFileSetWriter struct {
	ctrl     *gomock.Controller
	recorder *MockDataFileSetWriterMockRecorder
}

// MockDataFileSetWriterMockRecorder is the mock recorder for MockDataFileSetWriter
type MockDataFileSetWriterMockRecorder struct {
	mock *MockDataFileSetWriter
}

// NewMockDataFileSetWriter creates a new mock instance
func NewMockDataFileSetWriter(ctrl *gomock.Controller) *MockDataFileSetWriter {
	mock := &MockDataFileSetWriter{ctrl: ctrl}
	mock.recorder = &MockDataFileSetWriterMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockDataFileSetWriter) 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 *MockDataFileSetWriterMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDataFileSetWriter)(nil).Close))
}

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

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

// Write mocks base method
func (m *MockDataFileSetWriter) Write(arg0 ident.ID, arg1 ident.Tags, arg2 checked.Bytes, arg3 uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write
func (mr *MockDataFileSetWriterMockRecorder) Write(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockDataFileSetWriter)(nil).Write), arg0, arg1, arg2, arg3)
}

// WriteAll mocks base method
func (m *MockDataFileSetWriter) WriteAll(arg0 ident.ID, arg1 ident.Tags, arg2 []checked.Bytes, arg3 uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAll", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAll indicates an expected call of WriteAll
func (mr *MockDataFileSetWriterMockRecorder) WriteAll(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAll", reflect.TypeOf((*MockDataFileSetWriter)(nil).WriteAll), arg0, arg1, arg2, arg3)
}

// MockDataFileSetReader is a mock of DataFileSetReader interface
type MockDataFileSetReader struct {
	ctrl     *gomock.Controller
	recorder *MockDataFileSetReaderMockRecorder
}

// MockDataFileSetReaderMockRecorder is the mock recorder for MockDataFileSetReader
type MockDataFileSetReaderMockRecorder struct {
	mock *MockDataFileSetReader
}

// NewMockDataFileSetReader creates a new mock instance
func NewMockDataFileSetReader(ctrl *gomock.Controller) *MockDataFileSetReader {
	mock := &MockDataFileSetReader{ctrl: ctrl}
	mock.recorder = &MockDataFileSetReaderMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockDataFileSetReader) 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 *MockDataFileSetReaderMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDataFileSetReader)(nil).Close))
}

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

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

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

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

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

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

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

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

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

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

// Read mocks base method
func (m *MockDataFileSetReader) Read() (ident.ID, ident.TagIterator, checked.Bytes, uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read")
	ret0, _ := ret[0].(ident.ID)
	ret1, _ := ret[1].(ident.TagIterator)
	ret2, _ := ret[2].(checked.Bytes)
	ret3, _ := ret[3].(uint32)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

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

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

// ReadMetadata mocks base method
func (m *MockDataFileSetReader) ReadMetadata() (ident.ID, ident.TagIterator, int, uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMetadata")
	ret0, _ := ret[0].(ident.ID)
	ret1, _ := ret[1].(ident.TagIterator)
	ret2, _ := ret[2].(int)
	ret3, _ := ret[3].(uint32)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

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

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

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

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

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

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

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

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

// MockDataFileSetSeeker is a mock of DataFileSetSeeker interface
type MockDataFileSetSeeker struct {
	ctrl     *gomock.Controller
	recorder *MockDataFileSetSeekerMockRecorder
}

// MockDataFileSetSeekerMockRecorder is the mock recorder for MockDataFileSetSeeker
type MockDataFileSetSeekerMockRecorder struct {
	mock *MockDataFileSetSeeker
}

// NewMockDataFileSetSeeker creates a new mock instance
func NewMockDataFileSetSeeker(ctrl *gomock.Controller) *MockDataFileSetSeeker {
	mock := &MockDataFileSetSeeker{ctrl: ctrl}
	mock.recorder = &MockDataFileSetSeekerMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockDataFileSetSeeker) 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 *MockDataFileSetSeekerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDataFileSetSeeker)(nil).Close))
}

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

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

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

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

// Open mocks base method
func (m *MockDataFileSetSeeker) Open(arg0 ident.ID, arg1 uint32, arg2 time.Time, arg3 int, arg4 ReusableSeekerResources) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Open", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// Open indicates an expected call of Open
func (mr *MockDataFileSetSeekerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockDataFileSetSeeker)(nil).Open), arg0, arg1, arg2, arg3, arg4)
}

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

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

// SeekByID mocks base method
func (m *MockDataFileSetSeeker) SeekByID(arg0 ident.ID, arg1 ReusableSeekerResources) (checked.Bytes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekByID", arg0, arg1)
	ret0, _ := ret[0].(checked.Bytes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SeekByIndexEntry mocks base method
func (m *MockDataFileSetSeeker) SeekByIndexEntry(arg0 IndexEntry, arg1 ReusableSeekerResources) (checked.Bytes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekByIndexEntry", arg0, arg1)
	ret0, _ := ret[0].(checked.Bytes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SeekIndexEntry mocks base method
func (m *MockDataFileSetSeeker) SeekIndexEntry(arg0 ident.ID, arg1 ReusableSeekerResources) (IndexEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekIndexEntry", arg0, arg1)
	ret0, _ := ret[0].(IndexEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIndexFileSetWriter is a mock of IndexFileSetWriter interface
type MockIndexFileSetWriter struct {
	ctrl     *gomock.Controller
	recorder *MockIndexFileSetWriterMockRecorder
}

// MockIndexFileSetWriterMockRecorder is the mock recorder for MockIndexFileSetWriter
type MockIndexFileSetWriterMockRecorder struct {
	mock *MockIndexFileSetWriter
}

// NewMockIndexFileSetWriter creates a new mock instance
func NewMockIndexFileSetWriter(ctrl *gomock.Controller) *MockIndexFileSetWriter {
	mock := &MockIndexFileSetWriter{ctrl: ctrl}
	mock.recorder = &MockIndexFileSetWriterMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockIndexFileSetWriter) 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 *MockIndexFileSetWriterMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockIndexFileSetWriter)(nil).Close))
}

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

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

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

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

// MockIndexFileSetReader is a mock of IndexFileSetReader interface
type MockIndexFileSetReader struct {
	ctrl     *gomock.Controller
	recorder *MockIndexFileSetReaderMockRecorder
}

// MockIndexFileSetReaderMockRecorder is the mock recorder for MockIndexFileSetReader
type MockIndexFileSetReaderMockRecorder struct {
	mock *MockIndexFileSetReader
}

// NewMockIndexFileSetReader creates a new mock instance
func NewMockIndexFileSetReader(ctrl *gomock.Controller) *MockIndexFileSetReader {
	mock := &MockIndexFileSetReader{ctrl: ctrl}
	mock.recorder = &MockIndexFileSetReaderMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockIndexFileSetReader) 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 *MockIndexFileSetReaderMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockIndexFileSetReader)(nil).Close))
}

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

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

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

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

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

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

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

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

// MockIndexSegmentFileSetWriter is a mock of IndexSegmentFileSetWriter interface
type MockIndexSegmentFileSetWriter struct {
	ctrl     *gomock.Controller
	recorder *MockIndexSegmentFileSetWriterMockRecorder
}

// MockIndexSegmentFileSetWriterMockRecorder is the mock recorder for MockIndexSegmentFileSetWriter
type MockIndexSegmentFileSetWriterMockRecorder struct {
	mock *MockIndexSegmentFileSetWriter
}

// NewMockIndexSegmentFileSetWriter creates a new mock instance
func NewMockIndexSegmentFileSetWriter(ctrl *gomock.Controller) *MockIndexSegmentFileSetWriter {
	mock := &MockIndexSegmentFileSetWriter{ctrl: ctrl}
	mock.recorder = &MockIndexSegmentFileSetWriterMockRecorder{mock}
	return mock
}

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

// Files mocks base method
func (m *MockIndexSegmentFileSetWriter) Files() []persist.IndexSegmentFileType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Files")
	ret0, _ := ret[0].([]persist.IndexSegmentFileType)
	return ret0
}

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

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

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

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

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

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

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

// SegmentType mocks base method
func (m *MockIndexSegmentFileSetWriter) SegmentType() persist.IndexSegmentType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SegmentType")
	ret0, _ := ret[0].(persist.IndexSegmentType)
	return ret0
}

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

// WriteFile mocks base method
func (m *MockIndexSegmentFileSetWriter) WriteFile(arg0 persist.IndexSegmentFileType, arg1 io.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteFile", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockIndexSegmentFileSet is a mock of IndexSegmentFileSet interface
type MockIndexSegmentFileSet struct {
	ctrl     *gomock.Controller
	recorder *MockIndexSegmentFileSetMockRecorder
}

// MockIndexSegmentFileSetMockRecorder is the mock recorder for MockIndexSegmentFileSet
type MockIndexSegmentFileSetMockRecorder struct {
	mock *MockIndexSegmentFileSet
}

// NewMockIndexSegmentFileSet creates a new mock instance
func NewMockIndexSegmentFileSet(ctrl *gomock.Controller) *MockIndexSegmentFileSet {
	mock := &MockIndexSegmentFileSet{ctrl: ctrl}
	mock.recorder = &MockIndexSegmentFileSetMockRecorder{mock}
	return mock
}

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

// Files mocks base method
func (m *MockIndexSegmentFileSet) Files() []persist.IndexSegmentFile {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Files")
	ret0, _ := ret[0].([]persist.IndexSegmentFile)
	return ret0
}

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

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

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

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

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

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

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

// SegmentType mocks base method
func (m *MockIndexSegmentFileSet) SegmentType() persist.IndexSegmentType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SegmentType")
	ret0, _ := ret[0].(persist.IndexSegmentType)
	return ret0
}

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

// MockIndexSegmentFile is a mock of IndexSegmentFile interface
type MockIndexSegmentFile struct {
	ctrl     *gomock.Controller
	recorder *MockIndexSegmentFileMockRecorder
}

// MockIndexSegmentFileMockRecorder is the mock recorder for MockIndexSegmentFile
type MockIndexSegmentFileMockRecorder struct {
	mock *MockIndexSegmentFile
}

// NewMockIndexSegmentFile creates a new mock instance
func NewMockIndexSegmentFile(ctrl *gomock.Controller) *MockIndexSegmentFile {
	mock := &MockIndexSegmentFile{ctrl: ctrl}
	mock.recorder = &MockIndexSegmentFileMockRecorder{mock}
	return mock
}

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

// Files mocks base method
func (m *MockIndexSegmentFile) Files() []persist.IndexSegmentFile {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Files")
	ret0, _ := ret[0].([]persist.IndexSegmentFile)
	return ret0
}

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

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

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

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

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

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

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

// SegmentType mocks base method
func (m *MockIndexSegmentFile) SegmentType() persist.IndexSegmentType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SegmentType")
	ret0, _ := ret[0].(persist.IndexSegmentType)
	return ret0
}

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

// MockSnapshotMetadataFileWriter is a mock of SnapshotMetadataFileWriter interface
type MockSnapshotMetadataFileWriter struct {
	ctrl     *gomock.Controller
	recorder *MockSnapshotMetadataFileWriterMockRecorder
}

// MockSnapshotMetadataFileWriterMockRecorder is the mock recorder for MockSnapshotMetadataFileWriter
type MockSnapshotMetadataFileWriterMockRecorder struct {
	mock *MockSnapshotMetadataFileWriter
}

// NewMockSnapshotMetadataFileWriter creates a new mock instance
func NewMockSnapshotMetadataFileWriter(ctrl *gomock.Controller) *MockSnapshotMetadataFileWriter {
	mock := &MockSnapshotMetadataFileWriter{ctrl: ctrl}
	mock.recorder = &MockSnapshotMetadataFileWriterMockRecorder{mock}
	return mock
}

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

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

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

// MockDataFileSetSeekerManager is a mock of DataFileSetSeekerManager interface
type MockDataFileSetSeekerManager struct {
	ctrl     *gomock.Controller
	recorder *MockDataFileSetSeekerManagerMockRecorder
}

// MockDataFileSetSeekerManagerMockRecorder is the mock recorder for MockDataFileSetSeekerManager
type MockDataFileSetSeekerManagerMockRecorder struct {
	mock *MockDataFileSetSeekerManager
}

// NewMockDataFileSetSeekerManager creates a new mock instance
func NewMockDataFileSetSeekerManager(ctrl *gomock.Controller) *MockDataFileSetSeekerManager {
	mock := &MockDataFileSetSeekerManager{ctrl: ctrl}
	mock.recorder = &MockDataFileSetSeekerManagerMockRecorder{mock}
	return mock
}

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

// Borrow mocks base method
func (m *MockDataFileSetSeekerManager) Borrow(arg0 uint32, arg1 time.Time) (ConcurrentDataFileSetSeeker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Borrow", arg0, arg1)
	ret0, _ := ret[0].(ConcurrentDataFileSetSeeker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Close mocks base method
func (m *MockDataFileSetSeekerManager) 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 *MockDataFileSetSeekerManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDataFileSetSeekerManager)(nil).Close))
}

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

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

// Return mocks base method
func (m *MockDataFileSetSeekerManager) Return(arg0 uint32, arg1 time.Time, arg2 ConcurrentDataFileSetSeeker) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Return", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Return indicates an expected call of Return
func (mr *MockDataFileSetSeekerManagerMockRecorder) Return(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Return", reflect.TypeOf((*MockDataFileSetSeekerManager)(nil).Return), arg0, arg1, arg2)
}

// Test mocks base method
func (m *MockDataFileSetSeekerManager) Test(arg0 ident.ID, arg1 uint32, arg2 time.Time) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Test", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Test indicates an expected call of Test
func (mr *MockDataFileSetSeekerManagerMockRecorder) Test(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Test", reflect.TypeOf((*MockDataFileSetSeekerManager)(nil).Test), arg0, arg1, arg2)
}

// MockConcurrentDataFileSetSeeker is a mock of ConcurrentDataFileSetSeeker interface
type MockConcurrentDataFileSetSeeker struct {
	ctrl     *gomock.Controller
	recorder *MockConcurrentDataFileSetSeekerMockRecorder
}

// MockConcurrentDataFileSetSeekerMockRecorder is the mock recorder for MockConcurrentDataFileSetSeeker
type MockConcurrentDataFileSetSeekerMockRecorder struct {
	mock *MockConcurrentDataFileSetSeeker
}

// NewMockConcurrentDataFileSetSeeker creates a new mock instance
func NewMockConcurrentDataFileSetSeeker(ctrl *gomock.Controller) *MockConcurrentDataFileSetSeeker {
	mock := &MockConcurrentDataFileSetSeeker{ctrl: ctrl}
	mock.recorder = &MockConcurrentDataFileSetSeekerMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockConcurrentDataFileSetSeeker) 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 *MockConcurrentDataFileSetSeekerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConcurrentDataFileSetSeeker)(nil).Close))
}

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

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

// SeekByID mocks base method
func (m *MockConcurrentDataFileSetSeeker) SeekByID(arg0 ident.ID, arg1 ReusableSeekerResources) (checked.Bytes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekByID", arg0, arg1)
	ret0, _ := ret[0].(checked.Bytes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SeekByIndexEntry mocks base method
func (m *MockConcurrentDataFileSetSeeker) SeekByIndexEntry(arg0 IndexEntry, arg1 ReusableSeekerResources) (checked.Bytes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekByIndexEntry", arg0, arg1)
	ret0, _ := ret[0].(checked.Bytes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SeekIndexEntry mocks base method
func (m *MockConcurrentDataFileSetSeeker) SeekIndexEntry(arg0 ident.ID, arg1 ReusableSeekerResources) (IndexEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeekIndexEntry", arg0, arg1)
	ret0, _ := ret[0].(IndexEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockMergeWith is a mock of MergeWith interface
type MockMergeWith struct {
	ctrl     *gomock.Controller
	recorder *MockMergeWithMockRecorder
}

// MockMergeWithMockRecorder is the mock recorder for MockMergeWith
type MockMergeWithMockRecorder struct {
	mock *MockMergeWith
}

// NewMockMergeWith creates a new mock instance
func NewMockMergeWith(ctrl *gomock.Controller) *MockMergeWith {
	mock := &MockMergeWith{ctrl: ctrl}
	mock.recorder = &MockMergeWithMockRecorder{mock}
	return mock
}

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

// ForEachRemaining mocks base method
func (m *MockMergeWith) ForEachRemaining(arg0 context.Context, arg1 time0.UnixNano, arg2 ForEachRemainingFn, arg3 namespace.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForEachRemaining", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForEachRemaining indicates an expected call of ForEachRemaining
func (mr *MockMergeWithMockRecorder) ForEachRemaining(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForEachRemaining", reflect.TypeOf((*MockMergeWith)(nil).ForEachRemaining), arg0, arg1, arg2, arg3)
}

// Read mocks base method
func (m *MockMergeWith) Read(arg0 context.Context, arg1 ident.ID, arg2 time0.UnixNano, arg3 namespace.Context) ([]xio.BlockReader, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]xio.BlockReader)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Read indicates an expected call of Read
func (mr *MockMergeWithMockRecorder) Read(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockMergeWith)(nil).Read), arg0, arg1, arg2, arg3)
}