mock_meta.go

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

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

import (
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockSerializable is a mock of Serializable interface
type MockSerializable struct {
	ctrl     *gomock.Controller
	recorder *MockSerializableMockRecorder
}

// MockSerializableMockRecorder is the mock recorder for MockSerializable
type MockSerializableMockRecorder struct {
	mock *MockSerializable
}

// NewMockSerializable creates a new mock instance
func NewMockSerializable(ctrl *gomock.Controller) *MockSerializable {
	mock := &MockSerializable{ctrl: ctrl}
	mock.recorder = &MockSerializableMockRecorder{mock}
	return mock
}

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

// MockcodecSerializable is a mock of codecSerializable interface
type MockcodecSerializable struct {
	ctrl     *gomock.Controller
	recorder *MockcodecSerializableMockRecorder
}

// MockcodecSerializableMockRecorder is the mock recorder for MockcodecSerializable
type MockcodecSerializableMockRecorder struct {
	mock *MockcodecSerializable
}

// NewMockcodecSerializable creates a new mock instance
func NewMockcodecSerializable(ctrl *gomock.Controller) *MockcodecSerializable {
	mock := &MockcodecSerializable{ctrl: ctrl}
	mock.recorder = &MockcodecSerializableMockRecorder{mock}
	return mock
}

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

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

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

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

// Init indicates an expected call of Init
func (mr *MockcodecSerializableMockRecorder) Init(adapter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockcodecSerializable)(nil).Init), adapter)
}

// MockResource is a mock of Resource interface
type MockResource struct {
	ctrl     *gomock.Controller
	recorder *MockResourceMockRecorder
}

// MockResourceMockRecorder is the mock recorder for MockResource
type MockResourceMockRecorder struct {
	mock *MockResource
}

// NewMockResource creates a new mock instance
func NewMockResource(ctrl *gomock.Controller) *MockResource {
	mock := &MockResource{ctrl: ctrl}
	mock.recorder = &MockResourceMockRecorder{mock}
	return mock
}

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

// SetID mocks base method
func (m *MockResource) SetID(id uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetID", id)
}

// SetID indicates an expected call of SetID
func (mr *MockResourceMockRecorder) SetID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockResource)(nil).SetID), id)
}

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

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

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

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

// SetPeers mocks base method
func (m *MockResource) SetPeers(peers []*Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPeers", peers)
}

// SetPeers indicates an expected call of SetPeers
func (mr *MockResourceMockRecorder) SetPeers(peers interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPeers", reflect.TypeOf((*MockResource)(nil).SetPeers), peers)
}

// Stale mocks base method
func (m *MockResource) Stale(other Resource) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stale", other)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Stale indicates an expected call of Stale
func (mr *MockResourceMockRecorder) Stale(other interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stale", reflect.TypeOf((*MockResource)(nil).Stale), other)
}

// Changed mocks base method
func (m *MockResource) Changed(other Resource) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Changed", other)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Changed indicates an expected call of Changed
func (mr *MockResourceMockRecorder) Changed(other interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Changed", reflect.TypeOf((*MockResource)(nil).Changed), other)
}

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

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

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

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

// ScaleCompleted mocks base method
func (m *MockResource) ScaleCompleted(arg0 uint64) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScaleCompleted", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

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

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

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

// Unmarshal indicates an expected call of Unmarshal
func (mr *MockResourceMockRecorder) Unmarshal(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockResource)(nil).Unmarshal), data)
}

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

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

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

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

// MockContainer is a mock of Container interface
type MockContainer struct {
	ctrl     *gomock.Controller
	recorder *MockContainerMockRecorder
}

// MockContainerMockRecorder is the mock recorder for MockContainer
type MockContainerMockRecorder struct {
	mock *MockContainer
}

// NewMockContainer creates a new mock instance
func NewMockContainer(ctrl *gomock.Controller) *MockContainer {
	mock := &MockContainer{ctrl: ctrl}
	mock.recorder = &MockContainerMockRecorder{mock}
	return mock
}

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

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

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

// SetID mocks base method
func (m *MockContainer) SetID(id uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetID", id)
}

// SetID indicates an expected call of SetID
func (mr *MockContainerMockRecorder) SetID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockContainer)(nil).SetID), id)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Unmarshal indicates an expected call of Unmarshal
func (mr *MockContainerMockRecorder) Unmarshal(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockContainer)(nil).Unmarshal), data)
}