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

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

import (
	p2pcommon "github.com/aergoio/aergo/v2/p2p/p2pcommon"
	types "github.com/aergoio/aergo/v2/types"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
	time "time"
)

// MockMessage is a mock of Message interface
type MockMessage struct {
	ctrl     *gomock.Controller
	recorder *MockMessageMockRecorder
}

// MockMessageMockRecorder is the mock recorder for MockMessage
type MockMessageMockRecorder struct {
	mock *MockMessage
}

// NewMockMessage creates a new mock instance
func NewMockMessage(ctrl *gomock.Controller) *MockMessage {
	mock := &MockMessage{ctrl: ctrl}
	mock.recorder = &MockMessageMockRecorder{mock}
	return mock
}

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

// Subprotocol mocks base method
func (m *MockMessage) Subprotocol() p2pcommon.SubProtocol {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Subprotocol")
	ret0, _ := ret[0].(p2pcommon.SubProtocol)
	return ret0
}

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

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

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

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

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

// ID mocks base method
func (m *MockMessage) ID() p2pcommon.MsgID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(p2pcommon.MsgID)
	return ret0
}

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

// OriginalID mocks base method
func (m *MockMessage) OriginalID() p2pcommon.MsgID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OriginalID")
	ret0, _ := ret[0].(p2pcommon.MsgID)
	return ret0
}

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

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

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

// MockMessageBody is a mock of MessageBody interface
type MockMessageBody struct {
	ctrl     *gomock.Controller
	recorder *MockMessageBodyMockRecorder
}

// MockMessageBodyMockRecorder is the mock recorder for MockMessageBody
type MockMessageBodyMockRecorder struct {
	mock *MockMessageBody
}

// NewMockMessageBody creates a new mock instance
func NewMockMessageBody(ctrl *gomock.Controller) *MockMessageBody {
	mock := &MockMessageBody{ctrl: ctrl}
	mock.recorder = &MockMessageBodyMockRecorder{mock}
	return mock
}

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

// Reset mocks base method
func (m *MockMessageBody) Reset() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset")
}

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

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

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

// ProtoMessage mocks base method
func (m *MockMessageBody) ProtoMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProtoMessage")
}

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

// MockMessageHandler is a mock of MessageHandler interface
type MockMessageHandler struct {
	ctrl     *gomock.Controller
	recorder *MockMessageHandlerMockRecorder
}

// MockMessageHandlerMockRecorder is the mock recorder for MockMessageHandler
type MockMessageHandlerMockRecorder struct {
	mock *MockMessageHandler
}

// NewMockMessageHandler creates a new mock instance
func NewMockMessageHandler(ctrl *gomock.Controller) *MockMessageHandler {
	mock := &MockMessageHandler{ctrl: ctrl}
	mock.recorder = &MockMessageHandlerMockRecorder{mock}
	return mock
}

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

// AddAdvice mocks base method
func (m *MockMessageHandler) AddAdvice(advice p2pcommon.HandlerAdvice) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddAdvice", advice)
}

// AddAdvice indicates an expected call of AddAdvice
func (mr *MockMessageHandlerMockRecorder) AddAdvice(advice interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAdvice", reflect.TypeOf((*MockMessageHandler)(nil).AddAdvice), advice)
}

// ParsePayload mocks base method
func (m *MockMessageHandler) ParsePayload(arg0 []byte) (p2pcommon.MessageBody, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParsePayload", arg0)
	ret0, _ := ret[0].(p2pcommon.MessageBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckAuth mocks base method
func (m *MockMessageHandler) CheckAuth(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAuth", msg, msgBody)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckAuth indicates an expected call of CheckAuth
func (mr *MockMessageHandlerMockRecorder) CheckAuth(msg, msgBody interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAuth", reflect.TypeOf((*MockMessageHandler)(nil).CheckAuth), msg, msgBody)
}

// Handle mocks base method
func (m *MockMessageHandler) Handle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Handle", msg, msgBody)
}

// Handle indicates an expected call of Handle
func (mr *MockMessageHandlerMockRecorder) Handle(msg, msgBody interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockMessageHandler)(nil).Handle), msg, msgBody)
}

// PreHandle mocks base method
func (m *MockMessageHandler) PreHandle() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PreHandle")
}

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

// PostHandle mocks base method
func (m *MockMessageHandler) PostHandle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostHandle", msg, msgBody)
}

// PostHandle indicates an expected call of PostHandle
func (mr *MockMessageHandlerMockRecorder) PostHandle(msg, msgBody interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostHandle", reflect.TypeOf((*MockMessageHandler)(nil).PostHandle), msg, msgBody)
}

// MockHandlerAdvice is a mock of HandlerAdvice interface
type MockHandlerAdvice struct {
	ctrl     *gomock.Controller
	recorder *MockHandlerAdviceMockRecorder
}

// MockHandlerAdviceMockRecorder is the mock recorder for MockHandlerAdvice
type MockHandlerAdviceMockRecorder struct {
	mock *MockHandlerAdvice
}

// NewMockHandlerAdvice creates a new mock instance
func NewMockHandlerAdvice(ctrl *gomock.Controller) *MockHandlerAdvice {
	mock := &MockHandlerAdvice{ctrl: ctrl}
	mock.recorder = &MockHandlerAdviceMockRecorder{mock}
	return mock
}

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

// PreHandle mocks base method
func (m *MockHandlerAdvice) PreHandle() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PreHandle")
}

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

// PostHandle mocks base method
func (m *MockHandlerAdvice) PostHandle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostHandle", msg, msgBody)
}

// PostHandle indicates an expected call of PostHandle
func (mr *MockHandlerAdviceMockRecorder) PostHandle(msg, msgBody interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostHandle", reflect.TypeOf((*MockHandlerAdvice)(nil).PostHandle), msg, msgBody)
}

// MockAsyncHandler is a mock of AsyncHandler interface
type MockAsyncHandler struct {
	ctrl     *gomock.Controller
	recorder *MockAsyncHandlerMockRecorder
}

// MockAsyncHandlerMockRecorder is the mock recorder for MockAsyncHandler
type MockAsyncHandlerMockRecorder struct {
	mock *MockAsyncHandler
}

// NewMockAsyncHandler creates a new mock instance
func NewMockAsyncHandler(ctrl *gomock.Controller) *MockAsyncHandler {
	mock := &MockAsyncHandler{ctrl: ctrl}
	mock.recorder = &MockAsyncHandlerMockRecorder{mock}
	return mock
}

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

// HandleOrNot mocks base method
func (m *MockAsyncHandler) HandleOrNot(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleOrNot", msg, msgBody)
	ret0, _ := ret[0].(bool)
	return ret0
}

// HandleOrNot indicates an expected call of HandleOrNot
func (mr *MockAsyncHandlerMockRecorder) HandleOrNot(msg, msgBody interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleOrNot", reflect.TypeOf((*MockAsyncHandler)(nil).HandleOrNot), msg, msgBody)
}

// Handle mocks base method
func (m *MockAsyncHandler) Handle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody, ttl time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Handle", msg, msgBody, ttl)
}

// Handle indicates an expected call of Handle
func (mr *MockAsyncHandlerMockRecorder) Handle(msg, msgBody, ttl interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockAsyncHandler)(nil).Handle), msg, msgBody, ttl)
}

// MockMsgSigner is a mock of MsgSigner interface
type MockMsgSigner struct {
	ctrl     *gomock.Controller
	recorder *MockMsgSignerMockRecorder
}

// MockMsgSignerMockRecorder is the mock recorder for MockMsgSigner
type MockMsgSignerMockRecorder struct {
	mock *MockMsgSigner
}

// NewMockMsgSigner creates a new mock instance
func NewMockMsgSigner(ctrl *gomock.Controller) *MockMsgSigner {
	mock := &MockMsgSigner{ctrl: ctrl}
	mock.recorder = &MockMsgSignerMockRecorder{mock}
	return mock
}

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

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

// SignMsg indicates an expected call of SignMsg
func (mr *MockMsgSignerMockRecorder) SignMsg(msg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMsg", reflect.TypeOf((*MockMsgSigner)(nil).SignMsg), msg)
}

// VerifyMsg mocks base method
func (m *MockMsgSigner) VerifyMsg(msg *types.P2PMessage, senderID types.PeerID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyMsg", msg, senderID)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyMsg indicates an expected call of VerifyMsg
func (mr *MockMsgSignerMockRecorder) VerifyMsg(msg, senderID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMsg", reflect.TypeOf((*MockMsgSigner)(nil).VerifyMsg), msg, senderID)
}
