mocks.go

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

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

import (
	reflect "reflect"

	types "github.com/spacemeshos/go-spacemesh/common/types"
	gomock "go.uber.org/mock/gomock"
)

// MockactiveSetCache is a mock of activeSetCache interface.
type MockactiveSetCache struct {
	ctrl     *gomock.Controller
	recorder *MockactiveSetCacheMockRecorder
}

// MockactiveSetCacheMockRecorder is the mock recorder for MockactiveSetCache.
type MockactiveSetCacheMockRecorder struct {
	mock *MockactiveSetCache
}

// NewMockactiveSetCache creates a new mock instance.
func NewMockactiveSetCache(ctrl *gomock.Controller) *MockactiveSetCache {
	mock := &MockactiveSetCache{ctrl: ctrl}
	mock.recorder = &MockactiveSetCacheMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockactiveSetCache) Add(key types.EpochID, value *cachedActiveSet) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", key, value)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockactiveSetCacheMockRecorder) Add(key, value interface{}) *activeSetCacheAddCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockactiveSetCache)(nil).Add), key, value)
	return &activeSetCacheAddCall{Call: call}
}

// activeSetCacheAddCall wrap *gomock.Call
type activeSetCacheAddCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *activeSetCacheAddCall) Return(evicted bool) *activeSetCacheAddCall {
	c.Call = c.Call.Return(evicted)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *activeSetCacheAddCall) Do(f func(types.EpochID, *cachedActiveSet) bool) *activeSetCacheAddCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *activeSetCacheAddCall) DoAndReturn(f func(types.EpochID, *cachedActiveSet) bool) *activeSetCacheAddCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockactiveSetCache) Get(key types.EpochID) (*cachedActiveSet, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(*cachedActiveSet)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockactiveSetCacheMockRecorder) Get(key interface{}) *activeSetCacheGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockactiveSetCache)(nil).Get), key)
	return &activeSetCacheGetCall{Call: call}
}

// activeSetCacheGetCall wrap *gomock.Call
type activeSetCacheGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *activeSetCacheGetCall) Return(value *cachedActiveSet, ok bool) *activeSetCacheGetCall {
	c.Call = c.Call.Return(value, ok)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *activeSetCacheGetCall) Do(f func(types.EpochID) (*cachedActiveSet, bool)) *activeSetCacheGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *activeSetCacheGetCall) DoAndReturn(f func(types.EpochID) (*cachedActiveSet, bool)) *activeSetCacheGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockvrfVerifier is a mock of vrfVerifier interface.
type MockvrfVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockvrfVerifierMockRecorder
}

// MockvrfVerifierMockRecorder is the mock recorder for MockvrfVerifier.
type MockvrfVerifierMockRecorder struct {
	mock *MockvrfVerifier
}

// NewMockvrfVerifier creates a new mock instance.
func NewMockvrfVerifier(ctrl *gomock.Controller) *MockvrfVerifier {
	mock := &MockvrfVerifier{ctrl: ctrl}
	mock.recorder = &MockvrfVerifierMockRecorder{mock}
	return mock
}

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

// Verify mocks base method.
func (m *MockvrfVerifier) Verify(nodeID types.NodeID, msg []byte, sig types.VrfSignature) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Verify", nodeID, msg, sig)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Verify indicates an expected call of Verify.
func (mr *MockvrfVerifierMockRecorder) Verify(nodeID, msg, sig interface{}) *vrfVerifierVerifyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*MockvrfVerifier)(nil).Verify), nodeID, msg, sig)
	return &vrfVerifierVerifyCall{Call: call}
}

// vrfVerifierVerifyCall wrap *gomock.Call
type vrfVerifierVerifyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *vrfVerifierVerifyCall) Return(arg0 bool) *vrfVerifierVerifyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *vrfVerifierVerifyCall) Do(f func(types.NodeID, []byte, types.VrfSignature) bool) *vrfVerifierVerifyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *vrfVerifierVerifyCall) DoAndReturn(f func(types.NodeID, []byte, types.VrfSignature) bool) *vrfVerifierVerifyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}