296 lines
7.6 KiB
Go
296 lines
7.6 KiB
Go
// Code generated by counterfeiter. DO NOT EDIT.
|
|
package mock
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/hyperledger/fabric/common/deliver"
|
|
"github.com/hyperledger/fabric/common/ledger/blockledger"
|
|
"github.com/hyperledger/fabric/common/policies"
|
|
)
|
|
|
|
type Chain struct {
|
|
ErroredStub func() <-chan struct{}
|
|
erroredMutex sync.RWMutex
|
|
erroredArgsForCall []struct {
|
|
}
|
|
erroredReturns struct {
|
|
result1 <-chan struct{}
|
|
}
|
|
erroredReturnsOnCall map[int]struct {
|
|
result1 <-chan struct{}
|
|
}
|
|
PolicyManagerStub func() policies.Manager
|
|
policyManagerMutex sync.RWMutex
|
|
policyManagerArgsForCall []struct {
|
|
}
|
|
policyManagerReturns struct {
|
|
result1 policies.Manager
|
|
}
|
|
policyManagerReturnsOnCall map[int]struct {
|
|
result1 policies.Manager
|
|
}
|
|
ReaderStub func() blockledger.Reader
|
|
readerMutex sync.RWMutex
|
|
readerArgsForCall []struct {
|
|
}
|
|
readerReturns struct {
|
|
result1 blockledger.Reader
|
|
}
|
|
readerReturnsOnCall map[int]struct {
|
|
result1 blockledger.Reader
|
|
}
|
|
SequenceStub func() uint64
|
|
sequenceMutex sync.RWMutex
|
|
sequenceArgsForCall []struct {
|
|
}
|
|
sequenceReturns struct {
|
|
result1 uint64
|
|
}
|
|
sequenceReturnsOnCall map[int]struct {
|
|
result1 uint64
|
|
}
|
|
invocations map[string][][]interface{}
|
|
invocationsMutex sync.RWMutex
|
|
}
|
|
|
|
func (fake *Chain) Errored() <-chan struct{} {
|
|
fake.erroredMutex.Lock()
|
|
ret, specificReturn := fake.erroredReturnsOnCall[len(fake.erroredArgsForCall)]
|
|
fake.erroredArgsForCall = append(fake.erroredArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Errored", []interface{}{})
|
|
fake.erroredMutex.Unlock()
|
|
if fake.ErroredStub != nil {
|
|
return fake.ErroredStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.erroredReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Chain) ErroredCallCount() int {
|
|
fake.erroredMutex.RLock()
|
|
defer fake.erroredMutex.RUnlock()
|
|
return len(fake.erroredArgsForCall)
|
|
}
|
|
|
|
func (fake *Chain) ErroredCalls(stub func() <-chan struct{}) {
|
|
fake.erroredMutex.Lock()
|
|
defer fake.erroredMutex.Unlock()
|
|
fake.ErroredStub = stub
|
|
}
|
|
|
|
func (fake *Chain) ErroredReturns(result1 <-chan struct{}) {
|
|
fake.erroredMutex.Lock()
|
|
defer fake.erroredMutex.Unlock()
|
|
fake.ErroredStub = nil
|
|
fake.erroredReturns = struct {
|
|
result1 <-chan struct{}
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) ErroredReturnsOnCall(i int, result1 <-chan struct{}) {
|
|
fake.erroredMutex.Lock()
|
|
defer fake.erroredMutex.Unlock()
|
|
fake.ErroredStub = nil
|
|
if fake.erroredReturnsOnCall == nil {
|
|
fake.erroredReturnsOnCall = make(map[int]struct {
|
|
result1 <-chan struct{}
|
|
})
|
|
}
|
|
fake.erroredReturnsOnCall[i] = struct {
|
|
result1 <-chan struct{}
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) PolicyManager() policies.Manager {
|
|
fake.policyManagerMutex.Lock()
|
|
ret, specificReturn := fake.policyManagerReturnsOnCall[len(fake.policyManagerArgsForCall)]
|
|
fake.policyManagerArgsForCall = append(fake.policyManagerArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("PolicyManager", []interface{}{})
|
|
fake.policyManagerMutex.Unlock()
|
|
if fake.PolicyManagerStub != nil {
|
|
return fake.PolicyManagerStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.policyManagerReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Chain) PolicyManagerCallCount() int {
|
|
fake.policyManagerMutex.RLock()
|
|
defer fake.policyManagerMutex.RUnlock()
|
|
return len(fake.policyManagerArgsForCall)
|
|
}
|
|
|
|
func (fake *Chain) PolicyManagerCalls(stub func() policies.Manager) {
|
|
fake.policyManagerMutex.Lock()
|
|
defer fake.policyManagerMutex.Unlock()
|
|
fake.PolicyManagerStub = stub
|
|
}
|
|
|
|
func (fake *Chain) PolicyManagerReturns(result1 policies.Manager) {
|
|
fake.policyManagerMutex.Lock()
|
|
defer fake.policyManagerMutex.Unlock()
|
|
fake.PolicyManagerStub = nil
|
|
fake.policyManagerReturns = struct {
|
|
result1 policies.Manager
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) PolicyManagerReturnsOnCall(i int, result1 policies.Manager) {
|
|
fake.policyManagerMutex.Lock()
|
|
defer fake.policyManagerMutex.Unlock()
|
|
fake.PolicyManagerStub = nil
|
|
if fake.policyManagerReturnsOnCall == nil {
|
|
fake.policyManagerReturnsOnCall = make(map[int]struct {
|
|
result1 policies.Manager
|
|
})
|
|
}
|
|
fake.policyManagerReturnsOnCall[i] = struct {
|
|
result1 policies.Manager
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) Reader() blockledger.Reader {
|
|
fake.readerMutex.Lock()
|
|
ret, specificReturn := fake.readerReturnsOnCall[len(fake.readerArgsForCall)]
|
|
fake.readerArgsForCall = append(fake.readerArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Reader", []interface{}{})
|
|
fake.readerMutex.Unlock()
|
|
if fake.ReaderStub != nil {
|
|
return fake.ReaderStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.readerReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Chain) ReaderCallCount() int {
|
|
fake.readerMutex.RLock()
|
|
defer fake.readerMutex.RUnlock()
|
|
return len(fake.readerArgsForCall)
|
|
}
|
|
|
|
func (fake *Chain) ReaderCalls(stub func() blockledger.Reader) {
|
|
fake.readerMutex.Lock()
|
|
defer fake.readerMutex.Unlock()
|
|
fake.ReaderStub = stub
|
|
}
|
|
|
|
func (fake *Chain) ReaderReturns(result1 blockledger.Reader) {
|
|
fake.readerMutex.Lock()
|
|
defer fake.readerMutex.Unlock()
|
|
fake.ReaderStub = nil
|
|
fake.readerReturns = struct {
|
|
result1 blockledger.Reader
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) ReaderReturnsOnCall(i int, result1 blockledger.Reader) {
|
|
fake.readerMutex.Lock()
|
|
defer fake.readerMutex.Unlock()
|
|
fake.ReaderStub = nil
|
|
if fake.readerReturnsOnCall == nil {
|
|
fake.readerReturnsOnCall = make(map[int]struct {
|
|
result1 blockledger.Reader
|
|
})
|
|
}
|
|
fake.readerReturnsOnCall[i] = struct {
|
|
result1 blockledger.Reader
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) Sequence() uint64 {
|
|
fake.sequenceMutex.Lock()
|
|
ret, specificReturn := fake.sequenceReturnsOnCall[len(fake.sequenceArgsForCall)]
|
|
fake.sequenceArgsForCall = append(fake.sequenceArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Sequence", []interface{}{})
|
|
fake.sequenceMutex.Unlock()
|
|
if fake.SequenceStub != nil {
|
|
return fake.SequenceStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.sequenceReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Chain) SequenceCallCount() int {
|
|
fake.sequenceMutex.RLock()
|
|
defer fake.sequenceMutex.RUnlock()
|
|
return len(fake.sequenceArgsForCall)
|
|
}
|
|
|
|
func (fake *Chain) SequenceCalls(stub func() uint64) {
|
|
fake.sequenceMutex.Lock()
|
|
defer fake.sequenceMutex.Unlock()
|
|
fake.SequenceStub = stub
|
|
}
|
|
|
|
func (fake *Chain) SequenceReturns(result1 uint64) {
|
|
fake.sequenceMutex.Lock()
|
|
defer fake.sequenceMutex.Unlock()
|
|
fake.SequenceStub = nil
|
|
fake.sequenceReturns = struct {
|
|
result1 uint64
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) SequenceReturnsOnCall(i int, result1 uint64) {
|
|
fake.sequenceMutex.Lock()
|
|
defer fake.sequenceMutex.Unlock()
|
|
fake.SequenceStub = nil
|
|
if fake.sequenceReturnsOnCall == nil {
|
|
fake.sequenceReturnsOnCall = make(map[int]struct {
|
|
result1 uint64
|
|
})
|
|
}
|
|
fake.sequenceReturnsOnCall[i] = struct {
|
|
result1 uint64
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Chain) Invocations() map[string][][]interface{} {
|
|
fake.invocationsMutex.RLock()
|
|
defer fake.invocationsMutex.RUnlock()
|
|
fake.erroredMutex.RLock()
|
|
defer fake.erroredMutex.RUnlock()
|
|
fake.policyManagerMutex.RLock()
|
|
defer fake.policyManagerMutex.RUnlock()
|
|
fake.readerMutex.RLock()
|
|
defer fake.readerMutex.RUnlock()
|
|
fake.sequenceMutex.RLock()
|
|
defer fake.sequenceMutex.RUnlock()
|
|
copiedInvocations := map[string][][]interface{}{}
|
|
for key, value := range fake.invocations {
|
|
copiedInvocations[key] = value
|
|
}
|
|
return copiedInvocations
|
|
}
|
|
|
|
func (fake *Chain) recordInvocation(key string, args []interface{}) {
|
|
fake.invocationsMutex.Lock()
|
|
defer fake.invocationsMutex.Unlock()
|
|
if fake.invocations == nil {
|
|
fake.invocations = map[string][][]interface{}{}
|
|
}
|
|
if fake.invocations[key] == nil {
|
|
fake.invocations[key] = [][]interface{}{}
|
|
}
|
|
fake.invocations[key] = append(fake.invocations[key], args)
|
|
}
|
|
|
|
var _ deliver.Chain = new(Chain)
|