// Code generated by mockery v2.53.3. DO NOT EDIT.

package mock_segcore

import (
	context "context"

	segcore "github.com/milvus-io/milvus/internal/util/segcore"
	mock "github.com/stretchr/testify/mock"
)

// MockCSegment is an autogenerated mock type for the CSegment type
type MockCSegment struct {
	mock.Mock
}

type MockCSegment_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCSegment) EXPECT() *MockCSegment_Expecter {
	return &MockCSegment_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function with given fields: ctx, request
func (_m *MockCSegment) Delete(ctx context.Context, request *segcore.DeleteRequest) (*segcore.DeleteResult, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for Delete")
	}

	var r0 *segcore.DeleteResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.DeleteRequest) (*segcore.DeleteResult, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.DeleteRequest) *segcore.DeleteResult); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.DeleteResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.DeleteRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type MockCSegment_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - request *segcore.DeleteRequest
func (_e *MockCSegment_Expecter) Delete(ctx interface{}, request interface{}) *MockCSegment_Delete_Call {
	return &MockCSegment_Delete_Call{Call: _e.mock.On("Delete", ctx, request)}
}

func (_c *MockCSegment_Delete_Call) Run(run func(ctx context.Context, request *segcore.DeleteRequest)) *MockCSegment_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.DeleteRequest))
	})
	return _c
}

func (_c *MockCSegment_Delete_Call) Return(_a0 *segcore.DeleteResult, _a1 error) *MockCSegment_Delete_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_Delete_Call) RunAndReturn(run func(context.Context, *segcore.DeleteRequest) (*segcore.DeleteResult, error)) *MockCSegment_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// HasFieldData provides a mock function with given fields: fieldID
func (_m *MockCSegment) HasFieldData(fieldID int64) bool {
	ret := _m.Called(fieldID)

	if len(ret) == 0 {
		panic("no return value specified for HasFieldData")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(fieldID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockCSegment_HasFieldData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFieldData'
type MockCSegment_HasFieldData_Call struct {
	*mock.Call
}

// HasFieldData is a helper method to define mock.On call
//   - fieldID int64
func (_e *MockCSegment_Expecter) HasFieldData(fieldID interface{}) *MockCSegment_HasFieldData_Call {
	return &MockCSegment_HasFieldData_Call{Call: _e.mock.On("HasFieldData", fieldID)}
}

func (_c *MockCSegment_HasFieldData_Call) Run(run func(fieldID int64)) *MockCSegment_HasFieldData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockCSegment_HasFieldData_Call) Return(_a0 bool) *MockCSegment_HasFieldData_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_HasFieldData_Call) RunAndReturn(run func(int64) bool) *MockCSegment_HasFieldData_Call {
	_c.Call.Return(run)
	return _c
}

// HasRawData provides a mock function with given fields: fieldID
func (_m *MockCSegment) HasRawData(fieldID int64) bool {
	ret := _m.Called(fieldID)

	if len(ret) == 0 {
		panic("no return value specified for HasRawData")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(fieldID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockCSegment_HasRawData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasRawData'
type MockCSegment_HasRawData_Call struct {
	*mock.Call
}

// HasRawData is a helper method to define mock.On call
//   - fieldID int64
func (_e *MockCSegment_Expecter) HasRawData(fieldID interface{}) *MockCSegment_HasRawData_Call {
	return &MockCSegment_HasRawData_Call{Call: _e.mock.On("HasRawData", fieldID)}
}

func (_c *MockCSegment_HasRawData_Call) Run(run func(fieldID int64)) *MockCSegment_HasRawData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *MockCSegment_HasRawData_Call) Return(_a0 bool) *MockCSegment_HasRawData_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_HasRawData_Call) RunAndReturn(run func(int64) bool) *MockCSegment_HasRawData_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function with no fields
func (_m *MockCSegment) ID() int64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ID")
	}

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// MockCSegment_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
type MockCSegment_ID_Call struct {
	*mock.Call
}

// ID is a helper method to define mock.On call
func (_e *MockCSegment_Expecter) ID() *MockCSegment_ID_Call {
	return &MockCSegment_ID_Call{Call: _e.mock.On("ID")}
}

func (_c *MockCSegment_ID_Call) Run(run func()) *MockCSegment_ID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCSegment_ID_Call) Return(_a0 int64) *MockCSegment_ID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_ID_Call) RunAndReturn(run func() int64) *MockCSegment_ID_Call {
	_c.Call.Return(run)
	return _c
}

// Insert provides a mock function with given fields: ctx, request
func (_m *MockCSegment) Insert(ctx context.Context, request *segcore.InsertRequest) (*segcore.InsertResult, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for Insert")
	}

	var r0 *segcore.InsertResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.InsertRequest) (*segcore.InsertResult, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.InsertRequest) *segcore.InsertResult); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.InsertResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.InsertRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_Insert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Insert'
type MockCSegment_Insert_Call struct {
	*mock.Call
}

// Insert is a helper method to define mock.On call
//   - ctx context.Context
//   - request *segcore.InsertRequest
func (_e *MockCSegment_Expecter) Insert(ctx interface{}, request interface{}) *MockCSegment_Insert_Call {
	return &MockCSegment_Insert_Call{Call: _e.mock.On("Insert", ctx, request)}
}

func (_c *MockCSegment_Insert_Call) Run(run func(ctx context.Context, request *segcore.InsertRequest)) *MockCSegment_Insert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.InsertRequest))
	})
	return _c
}

func (_c *MockCSegment_Insert_Call) Return(_a0 *segcore.InsertResult, _a1 error) *MockCSegment_Insert_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_Insert_Call) RunAndReturn(run func(context.Context, *segcore.InsertRequest) (*segcore.InsertResult, error)) *MockCSegment_Insert_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function with given fields: ctx
func (_m *MockCSegment) Load(ctx context.Context) error {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Load")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockCSegment_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
type MockCSegment_Load_Call struct {
	*mock.Call
}

// Load is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockCSegment_Expecter) Load(ctx interface{}) *MockCSegment_Load_Call {
	return &MockCSegment_Load_Call{Call: _e.mock.On("Load", ctx)}
}

func (_c *MockCSegment_Load_Call) Run(run func(ctx context.Context)) *MockCSegment_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockCSegment_Load_Call) Return(_a0 error) *MockCSegment_Load_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_Load_Call) RunAndReturn(run func(context.Context) error) *MockCSegment_Load_Call {
	_c.Call.Return(run)
	return _c
}

// LoadFieldData provides a mock function with given fields: ctx, request
func (_m *MockCSegment) LoadFieldData(ctx context.Context, request *segcore.LoadFieldDataRequest) (*segcore.LoadFieldDataResult, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for LoadFieldData")
	}

	var r0 *segcore.LoadFieldDataResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.LoadFieldDataRequest) (*segcore.LoadFieldDataResult, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.LoadFieldDataRequest) *segcore.LoadFieldDataResult); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.LoadFieldDataResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.LoadFieldDataRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_LoadFieldData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadFieldData'
type MockCSegment_LoadFieldData_Call struct {
	*mock.Call
}

// LoadFieldData is a helper method to define mock.On call
//   - ctx context.Context
//   - request *segcore.LoadFieldDataRequest
func (_e *MockCSegment_Expecter) LoadFieldData(ctx interface{}, request interface{}) *MockCSegment_LoadFieldData_Call {
	return &MockCSegment_LoadFieldData_Call{Call: _e.mock.On("LoadFieldData", ctx, request)}
}

func (_c *MockCSegment_LoadFieldData_Call) Run(run func(ctx context.Context, request *segcore.LoadFieldDataRequest)) *MockCSegment_LoadFieldData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.LoadFieldDataRequest))
	})
	return _c
}

func (_c *MockCSegment_LoadFieldData_Call) Return(_a0 *segcore.LoadFieldDataResult, _a1 error) *MockCSegment_LoadFieldData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_LoadFieldData_Call) RunAndReturn(run func(context.Context, *segcore.LoadFieldDataRequest) (*segcore.LoadFieldDataResult, error)) *MockCSegment_LoadFieldData_Call {
	_c.Call.Return(run)
	return _c
}

// MemSize provides a mock function with no fields
func (_m *MockCSegment) MemSize() int64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for MemSize")
	}

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// MockCSegment_MemSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MemSize'
type MockCSegment_MemSize_Call struct {
	*mock.Call
}

// MemSize is a helper method to define mock.On call
func (_e *MockCSegment_Expecter) MemSize() *MockCSegment_MemSize_Call {
	return &MockCSegment_MemSize_Call{Call: _e.mock.On("MemSize")}
}

func (_c *MockCSegment_MemSize_Call) Run(run func()) *MockCSegment_MemSize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCSegment_MemSize_Call) Return(_a0 int64) *MockCSegment_MemSize_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_MemSize_Call) RunAndReturn(run func() int64) *MockCSegment_MemSize_Call {
	_c.Call.Return(run)
	return _c
}

// RawPointer provides a mock function with no fields
func (_m *MockCSegment) RawPointer() segcore.CSegmentInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RawPointer")
	}

	var r0 segcore.CSegmentInterface
	if rf, ok := ret.Get(0).(func() segcore.CSegmentInterface); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(segcore.CSegmentInterface)
	}

	return r0
}

// MockCSegment_RawPointer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RawPointer'
type MockCSegment_RawPointer_Call struct {
	*mock.Call
}

// RawPointer is a helper method to define mock.On call
func (_e *MockCSegment_Expecter) RawPointer() *MockCSegment_RawPointer_Call {
	return &MockCSegment_RawPointer_Call{Call: _e.mock.On("RawPointer")}
}

func (_c *MockCSegment_RawPointer_Call) Run(run func()) *MockCSegment_RawPointer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCSegment_RawPointer_Call) Return(_a0 segcore.CSegmentInterface) *MockCSegment_RawPointer_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_RawPointer_Call) RunAndReturn(run func() segcore.CSegmentInterface) *MockCSegment_RawPointer_Call {
	_c.Call.Return(run)
	return _c
}

// Release provides a mock function with no fields
func (_m *MockCSegment) Release() {
	_m.Called()
}

// MockCSegment_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
type MockCSegment_Release_Call struct {
	*mock.Call
}

// Release is a helper method to define mock.On call
func (_e *MockCSegment_Expecter) Release() *MockCSegment_Release_Call {
	return &MockCSegment_Release_Call{Call: _e.mock.On("Release")}
}

func (_c *MockCSegment_Release_Call) Run(run func()) *MockCSegment_Release_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCSegment_Release_Call) Return() *MockCSegment_Release_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockCSegment_Release_Call) RunAndReturn(run func()) *MockCSegment_Release_Call {
	_c.Run(run)
	return _c
}

// Reopen provides a mock function with given fields: ctx, request
func (_m *MockCSegment) Reopen(ctx context.Context, request *segcore.ReopenRequest) error {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for Reopen")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.ReopenRequest) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockCSegment_Reopen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reopen'
type MockCSegment_Reopen_Call struct {
	*mock.Call
}

// Reopen is a helper method to define mock.On call
//   - ctx context.Context
//   - request *segcore.ReopenRequest
func (_e *MockCSegment_Expecter) Reopen(ctx interface{}, request interface{}) *MockCSegment_Reopen_Call {
	return &MockCSegment_Reopen_Call{Call: _e.mock.On("Reopen", ctx, request)}
}

func (_c *MockCSegment_Reopen_Call) Run(run func(ctx context.Context, request *segcore.ReopenRequest)) *MockCSegment_Reopen_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.ReopenRequest))
	})
	return _c
}

func (_c *MockCSegment_Reopen_Call) Return(_a0 error) *MockCSegment_Reopen_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_Reopen_Call) RunAndReturn(run func(context.Context, *segcore.ReopenRequest) error) *MockCSegment_Reopen_Call {
	_c.Call.Return(run)
	return _c
}

// Retrieve provides a mock function with given fields: ctx, plan
func (_m *MockCSegment) Retrieve(ctx context.Context, plan *segcore.RetrievePlan) (*segcore.RetrieveResult, error) {
	ret := _m.Called(ctx, plan)

	if len(ret) == 0 {
		panic("no return value specified for Retrieve")
	}

	var r0 *segcore.RetrieveResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.RetrievePlan) (*segcore.RetrieveResult, error)); ok {
		return rf(ctx, plan)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.RetrievePlan) *segcore.RetrieveResult); ok {
		r0 = rf(ctx, plan)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.RetrieveResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.RetrievePlan) error); ok {
		r1 = rf(ctx, plan)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
type MockCSegment_Retrieve_Call struct {
	*mock.Call
}

// Retrieve is a helper method to define mock.On call
//   - ctx context.Context
//   - plan *segcore.RetrievePlan
func (_e *MockCSegment_Expecter) Retrieve(ctx interface{}, plan interface{}) *MockCSegment_Retrieve_Call {
	return &MockCSegment_Retrieve_Call{Call: _e.mock.On("Retrieve", ctx, plan)}
}

func (_c *MockCSegment_Retrieve_Call) Run(run func(ctx context.Context, plan *segcore.RetrievePlan)) *MockCSegment_Retrieve_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.RetrievePlan))
	})
	return _c
}

func (_c *MockCSegment_Retrieve_Call) Return(_a0 *segcore.RetrieveResult, _a1 error) *MockCSegment_Retrieve_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_Retrieve_Call) RunAndReturn(run func(context.Context, *segcore.RetrievePlan) (*segcore.RetrieveResult, error)) *MockCSegment_Retrieve_Call {
	_c.Call.Return(run)
	return _c
}

// RetrieveByOffsets provides a mock function with given fields: ctx, plan
func (_m *MockCSegment) RetrieveByOffsets(ctx context.Context, plan *segcore.RetrievePlanWithOffsets) (*segcore.RetrieveResult, error) {
	ret := _m.Called(ctx, plan)

	if len(ret) == 0 {
		panic("no return value specified for RetrieveByOffsets")
	}

	var r0 *segcore.RetrieveResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.RetrievePlanWithOffsets) (*segcore.RetrieveResult, error)); ok {
		return rf(ctx, plan)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.RetrievePlanWithOffsets) *segcore.RetrieveResult); ok {
		r0 = rf(ctx, plan)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.RetrieveResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.RetrievePlanWithOffsets) error); ok {
		r1 = rf(ctx, plan)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_RetrieveByOffsets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByOffsets'
type MockCSegment_RetrieveByOffsets_Call struct {
	*mock.Call
}

// RetrieveByOffsets is a helper method to define mock.On call
//   - ctx context.Context
//   - plan *segcore.RetrievePlanWithOffsets
func (_e *MockCSegment_Expecter) RetrieveByOffsets(ctx interface{}, plan interface{}) *MockCSegment_RetrieveByOffsets_Call {
	return &MockCSegment_RetrieveByOffsets_Call{Call: _e.mock.On("RetrieveByOffsets", ctx, plan)}
}

func (_c *MockCSegment_RetrieveByOffsets_Call) Run(run func(ctx context.Context, plan *segcore.RetrievePlanWithOffsets)) *MockCSegment_RetrieveByOffsets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.RetrievePlanWithOffsets))
	})
	return _c
}

func (_c *MockCSegment_RetrieveByOffsets_Call) Return(_a0 *segcore.RetrieveResult, _a1 error) *MockCSegment_RetrieveByOffsets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_RetrieveByOffsets_Call) RunAndReturn(run func(context.Context, *segcore.RetrievePlanWithOffsets) (*segcore.RetrieveResult, error)) *MockCSegment_RetrieveByOffsets_Call {
	_c.Call.Return(run)
	return _c
}

// RowNum provides a mock function with no fields
func (_m *MockCSegment) RowNum() int64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RowNum")
	}

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// MockCSegment_RowNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RowNum'
type MockCSegment_RowNum_Call struct {
	*mock.Call
}

// RowNum is a helper method to define mock.On call
func (_e *MockCSegment_Expecter) RowNum() *MockCSegment_RowNum_Call {
	return &MockCSegment_RowNum_Call{Call: _e.mock.On("RowNum")}
}

func (_c *MockCSegment_RowNum_Call) Run(run func()) *MockCSegment_RowNum_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockCSegment_RowNum_Call) Return(_a0 int64) *MockCSegment_RowNum_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockCSegment_RowNum_Call) RunAndReturn(run func() int64) *MockCSegment_RowNum_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function with given fields: ctx, searchReq
func (_m *MockCSegment) Search(ctx context.Context, searchReq *segcore.SearchRequest) (*segcore.SearchResult, error) {
	ret := _m.Called(ctx, searchReq)

	if len(ret) == 0 {
		panic("no return value specified for Search")
	}

	var r0 *segcore.SearchResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.SearchRequest) (*segcore.SearchResult, error)); ok {
		return rf(ctx, searchReq)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *segcore.SearchRequest) *segcore.SearchResult); ok {
		r0 = rf(ctx, searchReq)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*segcore.SearchResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *segcore.SearchRequest) error); ok {
		r1 = rf(ctx, searchReq)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockCSegment_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
type MockCSegment_Search_Call struct {
	*mock.Call
}

// Search is a helper method to define mock.On call
//   - ctx context.Context
//   - searchReq *segcore.SearchRequest
func (_e *MockCSegment_Expecter) Search(ctx interface{}, searchReq interface{}) *MockCSegment_Search_Call {
	return &MockCSegment_Search_Call{Call: _e.mock.On("Search", ctx, searchReq)}
}

func (_c *MockCSegment_Search_Call) Run(run func(ctx context.Context, searchReq *segcore.SearchRequest)) *MockCSegment_Search_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*segcore.SearchRequest))
	})
	return _c
}

func (_c *MockCSegment_Search_Call) Return(_a0 *segcore.SearchResult, _a1 error) *MockCSegment_Search_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCSegment_Search_Call) RunAndReturn(run func(context.Context, *segcore.SearchRequest) (*segcore.SearchResult, error)) *MockCSegment_Search_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockCSegment creates a new instance of MockCSegment. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockCSegment(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCSegment {
	mock := &MockCSegment{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
