func (m *MockSignedMessage) SetSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSignature", arg0)
}
SetSignature mocks base method
package mock_messages
import (
	gomock "github.com/golang/mock/gomock"
	usig "github.com/hyperledger-labs/minbft/usig"
	reflect "reflect"
)
type MockMessage struct {
	ctrl     *gomock.Controller
	recorder *MockMessageMockRecorder
}
type MockMessageMockRecorder struct {
	mock *MockMessage
}
func NewMockMessage(ctrl *gomock.Controller) *MockMessage {
	mock := &MockMessage{ctrl: ctrl}
	mock.recorder = &MockMessageMockRecorder{mock}
	return mock
}
func (m *MockMessage) EXPECT() *MockMessageMockRecorder {
	return m.recorder
}
func (m *MockMessage) MarshalBinary() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMessageMockRecorder) MarshalBinary() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalBinary", reflect.TypeOf((*MockMessage)(nil).MarshalBinary))
}
type MockClientMessage struct {
	ctrl     *gomock.Controller
	recorder *MockClientMessageMockRecorder
}
type MockClientMessageMockRecorder struct {
	mock *MockClientMessage
}
func NewMockClientMessage(ctrl *gomock.Controller) *MockClientMessage {
	mock := &MockClientMessage{ctrl: ctrl}
	mock.recorder = &MockClientMessageMockRecorder{mock}
	return mock
}
func (m *MockClientMessage) EXPECT() *MockClientMessageMockRecorder {
	return m.recorder
}
func (m *MockClientMessage) ClientID() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientID")
	ret0, _ := ret[0].(uint32)
	return ret0
}
func (mr *MockClientMessageMockRecorder) ClientID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockClientMessage)(nil).ClientID))
}
func (m *MockClientMessage) ImplementsClientMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ImplementsClientMessage")
}
func (mr *MockClientMessageMockRecorder) ImplementsClientMessage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplementsClientMessage", reflect.TypeOf((*MockClientMessage)(nil).ImplementsClientMessage))
}
func (m *MockClientMessage) MarshalBinary() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClientMessageMockRecorder) MarshalBinary() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalBinary", reflect.TypeOf((*MockClientMessage)(nil).MarshalBinary))
}
type MockReplicaMessage struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaMessageMockRecorder
}
type MockReplicaMessageMockRecorder struct {
	mock *MockReplicaMessage
}
func NewMockReplicaMessage(ctrl *gomock.Controller) *MockReplicaMessage {
	mock := &MockReplicaMessage{ctrl: ctrl}
	mock.recorder = &MockReplicaMessageMockRecorder{mock}
	return mock
}
func (m *MockReplicaMessage) EXPECT() *MockReplicaMessageMockRecorder {
	return m.recorder
}
func (m *MockReplicaMessage) ImplementsReplicaMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ImplementsReplicaMessage")
}
func (mr *MockReplicaMessageMockRecorder) ImplementsReplicaMessage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplementsReplicaMessage", reflect.TypeOf((*MockReplicaMessage)(nil).ImplementsReplicaMessage))
}
func (m *MockReplicaMessage) MarshalBinary() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockReplicaMessageMockRecorder) MarshalBinary() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalBinary", reflect.TypeOf((*MockReplicaMessage)(nil).MarshalBinary))
}
func (m *MockReplicaMessage) ReplicaID() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicaID")
	ret0, _ := ret[0].(uint32)
	return ret0
}
func (mr *MockReplicaMessageMockRecorder) ReplicaID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicaID", reflect.TypeOf((*MockReplicaMessage)(nil).ReplicaID))
}
type MockPeerMessage struct {
	ctrl     *gomock.Controller
	recorder *MockPeerMessageMockRecorder
}
type MockPeerMessageMockRecorder struct {
	mock *MockPeerMessage
}
func NewMockPeerMessage(ctrl *gomock.Controller) *MockPeerMessage {
	mock := &MockPeerMessage{ctrl: ctrl}
	mock.recorder = &MockPeerMessageMockRecorder{mock}
	return mock
}
func (m *MockPeerMessage) EXPECT() *MockPeerMessageMockRecorder {
	return m.recorder
}
func (m *MockPeerMessage) ImplementsPeerMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ImplementsPeerMessage")
}
func (mr *MockPeerMessageMockRecorder) ImplementsPeerMessage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplementsPeerMessage", reflect.TypeOf((*MockPeerMessage)(nil).ImplementsPeerMessage))
}
func (m *MockPeerMessage) ImplementsReplicaMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ImplementsReplicaMessage")
}
func (mr *MockPeerMessageMockRecorder) ImplementsReplicaMessage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplementsReplicaMessage", reflect.TypeOf((*MockPeerMessage)(nil).ImplementsReplicaMessage))
}
func (m *MockPeerMessage) MarshalBinary() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPeerMessageMockRecorder) MarshalBinary() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalBinary", reflect.TypeOf((*MockPeerMessage)(nil).MarshalBinary))
}
func (m *MockPeerMessage) ReplicaID() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicaID")
	ret0, _ := ret[0].(uint32)
	return ret0
}
func (mr *MockPeerMessageMockRecorder) ReplicaID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicaID", reflect.TypeOf((*MockPeerMessage)(nil).ReplicaID))
}
type MockCertifiedMessage struct {
	ctrl     *gomock.Controller
	recorder *MockCertifiedMessageMockRecorder
}
type MockCertifiedMessageMockRecorder struct {
	mock *MockCertifiedMessage
}
func NewMockCertifiedMessage(ctrl *gomock.Controller) *MockCertifiedMessage {
	mock := &MockCertifiedMessage{ctrl: ctrl}
	mock.recorder = &MockCertifiedMessageMockRecorder{mock}
	return mock
}
func (m *MockCertifiedMessage) EXPECT() *MockCertifiedMessageMockRecorder {
	return m.recorder
}
func (m *MockCertifiedMessage) ImplementsReplicaMessage() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ImplementsReplicaMessage")
}
func (mr *MockCertifiedMessageMockRecorder) ImplementsReplicaMessage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplementsReplicaMessage", reflect.TypeOf((*MockCertifiedMessage)(nil).ImplementsReplicaMessage))
}
func (m *MockCertifiedMessage) MarshalBinary() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalBinary")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockCertifiedMessageMockRecorder) MarshalBinary() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalBinary", reflect.TypeOf((*MockCertifiedMessage)(nil).MarshalBinary))
}
func (m *MockCertifiedMessage) ReplicaID() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicaID")
	ret0, _ := ret[0].(uint32)
	return ret0
}
func (mr *MockCertifiedMessageMockRecorder) ReplicaID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicaID", reflect.TypeOf((*MockCertifiedMessage)(nil).ReplicaID))
}
func (m *MockCertifiedMessage) SetUI(arg0 *usig.UI) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUI", arg0)
}
func (mr *MockCertifiedMessageMockRecorder) SetUI(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUI", reflect.TypeOf((*MockCertifiedMessage)(nil).SetUI), arg0)
}
func (m *MockCertifiedMessage) UI() *usig.UI {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UI")
	ret0, _ := ret[0].(*usig.UI)
	return ret0
}
func (mr *MockCertifiedMessageMockRecorder) UI() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UI", reflect.TypeOf((*MockCertifiedMessage)(nil).UI))
}
type MockSignedMessage struct {
	ctrl     *gomock.Controller
	recorder *MockSignedMessageMockRecorder
}
type MockSignedMessageMockRecorder struct {
	mock *MockSignedMessage
}
func NewMockSignedMessage(ctrl *gomock.Controller) *MockSignedMessage {
	mock := &MockSignedMessage{ctrl: ctrl}
	mock.recorder = &MockSignedMessageMockRecorder{mock}
	return mock
}
func (m *MockSignedMessage) EXPECT() *MockSignedMessageMockRecorder {
	return m.recorder
}