/*
 * Copyright 2022 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/


// Code generated by MockGen. DO NOT EDIT.
// Source: ../../pkg/remote/trans_handler.go

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

import (
	context "context"
	net "net"
	reflect "reflect"

	endpoint "github.com/cloudwego/kitex/pkg/endpoint"
	remote "github.com/cloudwego/kitex/pkg/remote"
	gomock "github.com/golang/mock/gomock"
)

// MockClientTransHandlerFactory is a mock of ClientTransHandlerFactory interface.
type MockClientTransHandlerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockClientTransHandlerFactoryMockRecorder
}

// MockClientTransHandlerFactoryMockRecorder is the mock recorder for MockClientTransHandlerFactory.
type MockClientTransHandlerFactoryMockRecorder struct {
	mock *MockClientTransHandlerFactory
}

// NewMockClientTransHandlerFactory creates a new mock instance.
func NewMockClientTransHandlerFactory(ctrl *gomock.Controller) *MockClientTransHandlerFactory {
	mock := &MockClientTransHandlerFactory{ctrl: ctrl}
	mock.recorder = &MockClientTransHandlerFactoryMockRecorder{mock}
	return mock
}

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

// NewTransHandler mocks base method.
func (m *MockClientTransHandlerFactory) NewTransHandler(opt *remote.ClientOption) (remote.ClientTransHandler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransHandler", opt)
	ret0, _ := ret[0].(remote.ClientTransHandler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransHandler indicates an expected call of NewTransHandler.
func (mr *MockClientTransHandlerFactoryMockRecorder) NewTransHandler(opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransHandler", reflect.TypeOf((*MockClientTransHandlerFactory)(nil).NewTransHandler), opt)
}

// MockServerTransHandlerFactory is a mock of ServerTransHandlerFactory interface.
type MockServerTransHandlerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockServerTransHandlerFactoryMockRecorder
}

// MockServerTransHandlerFactoryMockRecorder is the mock recorder for MockServerTransHandlerFactory.
type MockServerTransHandlerFactoryMockRecorder struct {
	mock *MockServerTransHandlerFactory
}

// NewMockServerTransHandlerFactory creates a new mock instance.
func NewMockServerTransHandlerFactory(ctrl *gomock.Controller) *MockServerTransHandlerFactory {
	mock := &MockServerTransHandlerFactory{ctrl: ctrl}
	mock.recorder = &MockServerTransHandlerFactoryMockRecorder{mock}
	return mock
}

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

// NewTransHandler mocks base method.
func (m *MockServerTransHandlerFactory) NewTransHandler(opt *remote.ServerOption) (remote.ServerTransHandler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransHandler", opt)
	ret0, _ := ret[0].(remote.ServerTransHandler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewTransHandler indicates an expected call of NewTransHandler.
func (mr *MockServerTransHandlerFactoryMockRecorder) NewTransHandler(opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTransHandler", reflect.TypeOf((*MockServerTransHandlerFactory)(nil).NewTransHandler), opt)
}

// MockTransReadWriter is a mock of TransReadWriter interface.
type MockTransReadWriter struct {
	ctrl     *gomock.Controller
	recorder *MockTransReadWriterMockRecorder
}

// MockTransReadWriterMockRecorder is the mock recorder for MockTransReadWriter.
type MockTransReadWriterMockRecorder struct {
	mock *MockTransReadWriter
}

// NewMockTransReadWriter creates a new mock instance.
func NewMockTransReadWriter(ctrl *gomock.Controller) *MockTransReadWriter {
	mock := &MockTransReadWriter{ctrl: ctrl}
	mock.recorder = &MockTransReadWriterMockRecorder{mock}
	return mock
}

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

// Read mocks base method.
func (m *MockTransReadWriter) Read(ctx context.Context, conn net.Conn, msg remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, conn, msg)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockTransReadWriterMockRecorder) Read(ctx, conn, msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockTransReadWriter)(nil).Read), ctx, conn, msg)
}

// Write mocks base method.
func (m *MockTransReadWriter) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockTransReadWriterMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTransReadWriter)(nil).Write), ctx, conn, send)
}

// MockTransHandler is a mock of TransHandler interface.
type MockTransHandler struct {
	ctrl     *gomock.Controller
	recorder *MockTransHandlerMockRecorder
}

// MockTransHandlerMockRecorder is the mock recorder for MockTransHandler.
type MockTransHandlerMockRecorder struct {
	mock *MockTransHandler
}

// NewMockTransHandler creates a new mock instance.
func NewMockTransHandler(ctrl *gomock.Controller) *MockTransHandler {
	mock := &MockTransHandler{ctrl: ctrl}
	mock.recorder = &MockTransHandlerMockRecorder{mock}
	return mock
}

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

// OnError mocks base method.
func (m *MockTransHandler) OnError(ctx context.Context, err error, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnError", ctx, err, conn)
}

// OnError indicates an expected call of OnError.
func (mr *MockTransHandlerMockRecorder) OnError(ctx, err, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnError", reflect.TypeOf((*MockTransHandler)(nil).OnError), ctx, err, conn)
}

// OnInactive mocks base method.
func (m *MockTransHandler) OnInactive(ctx context.Context, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInactive", ctx, conn)
}

// OnInactive indicates an expected call of OnInactive.
func (mr *MockTransHandlerMockRecorder) OnInactive(ctx, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInactive", reflect.TypeOf((*MockTransHandler)(nil).OnInactive), ctx, conn)
}

// OnMessage mocks base method.
func (m *MockTransHandler) OnMessage(ctx context.Context, args, result remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnMessage", ctx, args, result)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnMessage indicates an expected call of OnMessage.
func (mr *MockTransHandlerMockRecorder) OnMessage(ctx, args, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnMessage", reflect.TypeOf((*MockTransHandler)(nil).OnMessage), ctx, args, result)
}

// Read mocks base method.
func (m *MockTransHandler) Read(ctx context.Context, conn net.Conn, msg remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, conn, msg)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockTransHandlerMockRecorder) Read(ctx, conn, msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockTransHandler)(nil).Read), ctx, conn, msg)
}

// SetPipeline mocks base method.
func (m *MockTransHandler) SetPipeline(pipeline *remote.TransPipeline) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPipeline", pipeline)
}

// SetPipeline indicates an expected call of SetPipeline.
func (mr *MockTransHandlerMockRecorder) SetPipeline(pipeline interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPipeline", reflect.TypeOf((*MockTransHandler)(nil).SetPipeline), pipeline)
}

// Write mocks base method.
func (m *MockTransHandler) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockTransHandlerMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTransHandler)(nil).Write), ctx, conn, send)
}

// MockClientTransHandler is a mock of ClientTransHandler interface.
type MockClientTransHandler struct {
	ctrl     *gomock.Controller
	recorder *MockClientTransHandlerMockRecorder
}

// MockClientTransHandlerMockRecorder is the mock recorder for MockClientTransHandler.
type MockClientTransHandlerMockRecorder struct {
	mock *MockClientTransHandler
}

// NewMockClientTransHandler creates a new mock instance.
func NewMockClientTransHandler(ctrl *gomock.Controller) *MockClientTransHandler {
	mock := &MockClientTransHandler{ctrl: ctrl}
	mock.recorder = &MockClientTransHandlerMockRecorder{mock}
	return mock
}

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

// OnError mocks base method.
func (m *MockClientTransHandler) OnError(ctx context.Context, err error, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnError", ctx, err, conn)
}

// OnError indicates an expected call of OnError.
func (mr *MockClientTransHandlerMockRecorder) OnError(ctx, err, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnError", reflect.TypeOf((*MockClientTransHandler)(nil).OnError), ctx, err, conn)
}

// OnInactive mocks base method.
func (m *MockClientTransHandler) OnInactive(ctx context.Context, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInactive", ctx, conn)
}

// OnInactive indicates an expected call of OnInactive.
func (mr *MockClientTransHandlerMockRecorder) OnInactive(ctx, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInactive", reflect.TypeOf((*MockClientTransHandler)(nil).OnInactive), ctx, conn)
}

// OnMessage mocks base method.
func (m *MockClientTransHandler) OnMessage(ctx context.Context, args, result remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnMessage", ctx, args, result)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnMessage indicates an expected call of OnMessage.
func (mr *MockClientTransHandlerMockRecorder) OnMessage(ctx, args, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnMessage", reflect.TypeOf((*MockClientTransHandler)(nil).OnMessage), ctx, args, result)
}

// Read mocks base method.
func (m *MockClientTransHandler) Read(ctx context.Context, conn net.Conn, msg remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, conn, msg)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockClientTransHandlerMockRecorder) Read(ctx, conn, msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockClientTransHandler)(nil).Read), ctx, conn, msg)
}

// SetPipeline mocks base method.
func (m *MockClientTransHandler) SetPipeline(pipeline *remote.TransPipeline) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPipeline", pipeline)
}

// SetPipeline indicates an expected call of SetPipeline.
func (mr *MockClientTransHandlerMockRecorder) SetPipeline(pipeline interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPipeline", reflect.TypeOf((*MockClientTransHandler)(nil).SetPipeline), pipeline)
}

// Write mocks base method.
func (m *MockClientTransHandler) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockClientTransHandlerMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockClientTransHandler)(nil).Write), ctx, conn, send)
}

// MockServerTransHandler is a mock of ServerTransHandler interface.
type MockServerTransHandler struct {
	ctrl     *gomock.Controller
	recorder *MockServerTransHandlerMockRecorder
}

// MockServerTransHandlerMockRecorder is the mock recorder for MockServerTransHandler.
type MockServerTransHandlerMockRecorder struct {
	mock *MockServerTransHandler
}

// NewMockServerTransHandler creates a new mock instance.
func NewMockServerTransHandler(ctrl *gomock.Controller) *MockServerTransHandler {
	mock := &MockServerTransHandler{ctrl: ctrl}
	mock.recorder = &MockServerTransHandlerMockRecorder{mock}
	return mock
}

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

// OnActive mocks base method.
func (m *MockServerTransHandler) OnActive(ctx context.Context, conn net.Conn) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnActive", ctx, conn)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnActive indicates an expected call of OnActive.
func (mr *MockServerTransHandlerMockRecorder) OnActive(ctx, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnActive", reflect.TypeOf((*MockServerTransHandler)(nil).OnActive), ctx, conn)
}

// OnError mocks base method.
func (m *MockServerTransHandler) OnError(ctx context.Context, err error, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnError", ctx, err, conn)
}

// OnError indicates an expected call of OnError.
func (mr *MockServerTransHandlerMockRecorder) OnError(ctx, err, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnError", reflect.TypeOf((*MockServerTransHandler)(nil).OnError), ctx, err, conn)
}

// OnInactive mocks base method.
func (m *MockServerTransHandler) OnInactive(ctx context.Context, conn net.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnInactive", ctx, conn)
}

// OnInactive indicates an expected call of OnInactive.
func (mr *MockServerTransHandlerMockRecorder) OnInactive(ctx, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnInactive", reflect.TypeOf((*MockServerTransHandler)(nil).OnInactive), ctx, conn)
}

// OnMessage mocks base method.
func (m *MockServerTransHandler) OnMessage(ctx context.Context, args, result remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnMessage", ctx, args, result)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OnMessage indicates an expected call of OnMessage.
func (mr *MockServerTransHandlerMockRecorder) OnMessage(ctx, args, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnMessage", reflect.TypeOf((*MockServerTransHandler)(nil).OnMessage), ctx, args, result)
}

// OnRead mocks base method.
func (m *MockServerTransHandler) OnRead(ctx context.Context, conn net.Conn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnRead", ctx, conn)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnRead indicates an expected call of OnRead.
func (mr *MockServerTransHandlerMockRecorder) OnRead(ctx, conn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRead", reflect.TypeOf((*MockServerTransHandler)(nil).OnRead), ctx, conn)
}

// Read mocks base method.
func (m *MockServerTransHandler) Read(ctx context.Context, conn net.Conn, msg remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, conn, msg)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockServerTransHandlerMockRecorder) Read(ctx, conn, msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockServerTransHandler)(nil).Read), ctx, conn, msg)
}

// SetPipeline mocks base method.
func (m *MockServerTransHandler) SetPipeline(pipeline *remote.TransPipeline) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPipeline", pipeline)
}

// SetPipeline indicates an expected call of SetPipeline.
func (mr *MockServerTransHandlerMockRecorder) SetPipeline(pipeline interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPipeline", reflect.TypeOf((*MockServerTransHandler)(nil).SetPipeline), pipeline)
}

// Write mocks base method.
func (m *MockServerTransHandler) Write(ctx context.Context, conn net.Conn, send remote.Message) (context.Context, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, conn, send)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockServerTransHandlerMockRecorder) Write(ctx, conn, send interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockServerTransHandler)(nil).Write), ctx, conn, send)
}

// MockInvokeHandleFuncSetter is a mock of InvokeHandleFuncSetter interface.
type MockInvokeHandleFuncSetter struct {
	ctrl     *gomock.Controller
	recorder *MockInvokeHandleFuncSetterMockRecorder
}

// MockInvokeHandleFuncSetterMockRecorder is the mock recorder for MockInvokeHandleFuncSetter.
type MockInvokeHandleFuncSetterMockRecorder struct {
	mock *MockInvokeHandleFuncSetter
}

// NewMockInvokeHandleFuncSetter creates a new mock instance.
func NewMockInvokeHandleFuncSetter(ctrl *gomock.Controller) *MockInvokeHandleFuncSetter {
	mock := &MockInvokeHandleFuncSetter{ctrl: ctrl}
	mock.recorder = &MockInvokeHandleFuncSetterMockRecorder{mock}
	return mock
}

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

// SetInvokeHandleFunc mocks base method.
func (m *MockInvokeHandleFuncSetter) SetInvokeHandleFunc(inkHdlFunc endpoint.Endpoint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInvokeHandleFunc", inkHdlFunc)
}

// SetInvokeHandleFunc indicates an expected call of SetInvokeHandleFunc.
func (mr *MockInvokeHandleFuncSetterMockRecorder) SetInvokeHandleFunc(inkHdlFunc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInvokeHandleFunc", reflect.TypeOf((*MockInvokeHandleFuncSetter)(nil).SetInvokeHandleFunc), inkHdlFunc)
}

// MockGracefulShutdown is a mock of GracefulShutdown interface.
type MockGracefulShutdown struct {
	ctrl     *gomock.Controller
	recorder *MockGracefulShutdownMockRecorder
}

// MockGracefulShutdownMockRecorder is the mock recorder for MockGracefulShutdown.
type MockGracefulShutdownMockRecorder struct {
	mock *MockGracefulShutdown
}

// NewMockGracefulShutdown creates a new mock instance.
func NewMockGracefulShutdown(ctrl *gomock.Controller) *MockGracefulShutdown {
	mock := &MockGracefulShutdown{ctrl: ctrl}
	mock.recorder = &MockGracefulShutdownMockRecorder{mock}
	return mock
}

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

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

// GracefulShutdown indicates an expected call of GracefulShutdown.
func (mr *MockGracefulShutdownMockRecorder) GracefulShutdown(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GracefulShutdown", reflect.TypeOf((*MockGracefulShutdown)(nil).GracefulShutdown), ctx)
}
