Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
417 lines (383 sloc) 13.1 KB
// Code generated by counterfeiter. DO NOT EDIT.
package mocks
import (
"sync"
)
type OrdererCapabilities struct {
ConsensusTypeMigrationStub func() bool
consensusTypeMigrationMutex sync.RWMutex
consensusTypeMigrationArgsForCall []struct {
}
consensusTypeMigrationReturns struct {
result1 bool
}
consensusTypeMigrationReturnsOnCall map[int]struct {
result1 bool
}
ExpirationCheckStub func() bool
expirationCheckMutex sync.RWMutex
expirationCheckArgsForCall []struct {
}
expirationCheckReturns struct {
result1 bool
}
expirationCheckReturnsOnCall map[int]struct {
result1 bool
}
PredictableChannelTemplateStub func() bool
predictableChannelTemplateMutex sync.RWMutex
predictableChannelTemplateArgsForCall []struct {
}
predictableChannelTemplateReturns struct {
result1 bool
}
predictableChannelTemplateReturnsOnCall map[int]struct {
result1 bool
}
ResubmissionStub func() bool
resubmissionMutex sync.RWMutex
resubmissionArgsForCall []struct {
}
resubmissionReturns struct {
result1 bool
}
resubmissionReturnsOnCall map[int]struct {
result1 bool
}
SupportedStub func() error
supportedMutex sync.RWMutex
supportedArgsForCall []struct {
}
supportedReturns struct {
result1 error
}
supportedReturnsOnCall map[int]struct {
result1 error
}
UseChannelCreationPolicyAsAdminsStub func() bool
useChannelCreationPolicyAsAdminsMutex sync.RWMutex
useChannelCreationPolicyAsAdminsArgsForCall []struct {
}
useChannelCreationPolicyAsAdminsReturns struct {
result1 bool
}
useChannelCreationPolicyAsAdminsReturnsOnCall map[int]struct {
result1 bool
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *OrdererCapabilities) ConsensusTypeMigration() bool {
fake.consensusTypeMigrationMutex.Lock()
ret, specificReturn := fake.consensusTypeMigrationReturnsOnCall[len(fake.consensusTypeMigrationArgsForCall)]
fake.consensusTypeMigrationArgsForCall = append(fake.consensusTypeMigrationArgsForCall, struct {
}{})
fake.recordInvocation("ConsensusTypeMigration", []interface{}{})
fake.consensusTypeMigrationMutex.Unlock()
if fake.ConsensusTypeMigrationStub != nil {
return fake.ConsensusTypeMigrationStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.consensusTypeMigrationReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) ConsensusTypeMigrationCallCount() int {
fake.consensusTypeMigrationMutex.RLock()
defer fake.consensusTypeMigrationMutex.RUnlock()
return len(fake.consensusTypeMigrationArgsForCall)
}
func (fake *OrdererCapabilities) ConsensusTypeMigrationCalls(stub func() bool) {
fake.consensusTypeMigrationMutex.Lock()
defer fake.consensusTypeMigrationMutex.Unlock()
fake.ConsensusTypeMigrationStub = stub
}
func (fake *OrdererCapabilities) ConsensusTypeMigrationReturns(result1 bool) {
fake.consensusTypeMigrationMutex.Lock()
defer fake.consensusTypeMigrationMutex.Unlock()
fake.ConsensusTypeMigrationStub = nil
fake.consensusTypeMigrationReturns = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) ConsensusTypeMigrationReturnsOnCall(i int, result1 bool) {
fake.consensusTypeMigrationMutex.Lock()
defer fake.consensusTypeMigrationMutex.Unlock()
fake.ConsensusTypeMigrationStub = nil
if fake.consensusTypeMigrationReturnsOnCall == nil {
fake.consensusTypeMigrationReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.consensusTypeMigrationReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) ExpirationCheck() bool {
fake.expirationCheckMutex.Lock()
ret, specificReturn := fake.expirationCheckReturnsOnCall[len(fake.expirationCheckArgsForCall)]
fake.expirationCheckArgsForCall = append(fake.expirationCheckArgsForCall, struct {
}{})
fake.recordInvocation("ExpirationCheck", []interface{}{})
fake.expirationCheckMutex.Unlock()
if fake.ExpirationCheckStub != nil {
return fake.ExpirationCheckStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.expirationCheckReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) ExpirationCheckCallCount() int {
fake.expirationCheckMutex.RLock()
defer fake.expirationCheckMutex.RUnlock()
return len(fake.expirationCheckArgsForCall)
}
func (fake *OrdererCapabilities) ExpirationCheckCalls(stub func() bool) {
fake.expirationCheckMutex.Lock()
defer fake.expirationCheckMutex.Unlock()
fake.ExpirationCheckStub = stub
}
func (fake *OrdererCapabilities) ExpirationCheckReturns(result1 bool) {
fake.expirationCheckMutex.Lock()
defer fake.expirationCheckMutex.Unlock()
fake.ExpirationCheckStub = nil
fake.expirationCheckReturns = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) ExpirationCheckReturnsOnCall(i int, result1 bool) {
fake.expirationCheckMutex.Lock()
defer fake.expirationCheckMutex.Unlock()
fake.ExpirationCheckStub = nil
if fake.expirationCheckReturnsOnCall == nil {
fake.expirationCheckReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.expirationCheckReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) PredictableChannelTemplate() bool {
fake.predictableChannelTemplateMutex.Lock()
ret, specificReturn := fake.predictableChannelTemplateReturnsOnCall[len(fake.predictableChannelTemplateArgsForCall)]
fake.predictableChannelTemplateArgsForCall = append(fake.predictableChannelTemplateArgsForCall, struct {
}{})
fake.recordInvocation("PredictableChannelTemplate", []interface{}{})
fake.predictableChannelTemplateMutex.Unlock()
if fake.PredictableChannelTemplateStub != nil {
return fake.PredictableChannelTemplateStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.predictableChannelTemplateReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) PredictableChannelTemplateCallCount() int {
fake.predictableChannelTemplateMutex.RLock()
defer fake.predictableChannelTemplateMutex.RUnlock()
return len(fake.predictableChannelTemplateArgsForCall)
}
func (fake *OrdererCapabilities) PredictableChannelTemplateCalls(stub func() bool) {
fake.predictableChannelTemplateMutex.Lock()
defer fake.predictableChannelTemplateMutex.Unlock()
fake.PredictableChannelTemplateStub = stub
}
func (fake *OrdererCapabilities) PredictableChannelTemplateReturns(result1 bool) {
fake.predictableChannelTemplateMutex.Lock()
defer fake.predictableChannelTemplateMutex.Unlock()
fake.PredictableChannelTemplateStub = nil
fake.predictableChannelTemplateReturns = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) PredictableChannelTemplateReturnsOnCall(i int, result1 bool) {
fake.predictableChannelTemplateMutex.Lock()
defer fake.predictableChannelTemplateMutex.Unlock()
fake.PredictableChannelTemplateStub = nil
if fake.predictableChannelTemplateReturnsOnCall == nil {
fake.predictableChannelTemplateReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.predictableChannelTemplateReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) Resubmission() bool {
fake.resubmissionMutex.Lock()
ret, specificReturn := fake.resubmissionReturnsOnCall[len(fake.resubmissionArgsForCall)]
fake.resubmissionArgsForCall = append(fake.resubmissionArgsForCall, struct {
}{})
fake.recordInvocation("Resubmission", []interface{}{})
fake.resubmissionMutex.Unlock()
if fake.ResubmissionStub != nil {
return fake.ResubmissionStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.resubmissionReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) ResubmissionCallCount() int {
fake.resubmissionMutex.RLock()
defer fake.resubmissionMutex.RUnlock()
return len(fake.resubmissionArgsForCall)
}
func (fake *OrdererCapabilities) ResubmissionCalls(stub func() bool) {
fake.resubmissionMutex.Lock()
defer fake.resubmissionMutex.Unlock()
fake.ResubmissionStub = stub
}
func (fake *OrdererCapabilities) ResubmissionReturns(result1 bool) {
fake.resubmissionMutex.Lock()
defer fake.resubmissionMutex.Unlock()
fake.ResubmissionStub = nil
fake.resubmissionReturns = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) ResubmissionReturnsOnCall(i int, result1 bool) {
fake.resubmissionMutex.Lock()
defer fake.resubmissionMutex.Unlock()
fake.ResubmissionStub = nil
if fake.resubmissionReturnsOnCall == nil {
fake.resubmissionReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.resubmissionReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) Supported() error {
fake.supportedMutex.Lock()
ret, specificReturn := fake.supportedReturnsOnCall[len(fake.supportedArgsForCall)]
fake.supportedArgsForCall = append(fake.supportedArgsForCall, struct {
}{})
fake.recordInvocation("Supported", []interface{}{})
fake.supportedMutex.Unlock()
if fake.SupportedStub != nil {
return fake.SupportedStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.supportedReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) SupportedCallCount() int {
fake.supportedMutex.RLock()
defer fake.supportedMutex.RUnlock()
return len(fake.supportedArgsForCall)
}
func (fake *OrdererCapabilities) SupportedCalls(stub func() error) {
fake.supportedMutex.Lock()
defer fake.supportedMutex.Unlock()
fake.SupportedStub = stub
}
func (fake *OrdererCapabilities) SupportedReturns(result1 error) {
fake.supportedMutex.Lock()
defer fake.supportedMutex.Unlock()
fake.SupportedStub = nil
fake.supportedReturns = struct {
result1 error
}{result1}
}
func (fake *OrdererCapabilities) SupportedReturnsOnCall(i int, result1 error) {
fake.supportedMutex.Lock()
defer fake.supportedMutex.Unlock()
fake.SupportedStub = nil
if fake.supportedReturnsOnCall == nil {
fake.supportedReturnsOnCall = make(map[int]struct {
result1 error
})
}
fake.supportedReturnsOnCall[i] = struct {
result1 error
}{result1}
}
func (fake *OrdererCapabilities) UseChannelCreationPolicyAsAdmins() bool {
fake.useChannelCreationPolicyAsAdminsMutex.Lock()
ret, specificReturn := fake.useChannelCreationPolicyAsAdminsReturnsOnCall[len(fake.useChannelCreationPolicyAsAdminsArgsForCall)]
fake.useChannelCreationPolicyAsAdminsArgsForCall = append(fake.useChannelCreationPolicyAsAdminsArgsForCall, struct {
}{})
fake.recordInvocation("UseChannelCreationPolicyAsAdmins", []interface{}{})
fake.useChannelCreationPolicyAsAdminsMutex.Unlock()
if fake.UseChannelCreationPolicyAsAdminsStub != nil {
return fake.UseChannelCreationPolicyAsAdminsStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.useChannelCreationPolicyAsAdminsReturns
return fakeReturns.result1
}
func (fake *OrdererCapabilities) UseChannelCreationPolicyAsAdminsCallCount() int {
fake.useChannelCreationPolicyAsAdminsMutex.RLock()
defer fake.useChannelCreationPolicyAsAdminsMutex.RUnlock()
return len(fake.useChannelCreationPolicyAsAdminsArgsForCall)
}
func (fake *OrdererCapabilities) UseChannelCreationPolicyAsAdminsCalls(stub func() bool) {
fake.useChannelCreationPolicyAsAdminsMutex.Lock()
defer fake.useChannelCreationPolicyAsAdminsMutex.Unlock()
fake.UseChannelCreationPolicyAsAdminsStub = stub
}
func (fake *OrdererCapabilities) UseChannelCreationPolicyAsAdminsReturns(result1 bool) {
fake.useChannelCreationPolicyAsAdminsMutex.Lock()
defer fake.useChannelCreationPolicyAsAdminsMutex.Unlock()
fake.UseChannelCreationPolicyAsAdminsStub = nil
fake.useChannelCreationPolicyAsAdminsReturns = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) UseChannelCreationPolicyAsAdminsReturnsOnCall(i int, result1 bool) {
fake.useChannelCreationPolicyAsAdminsMutex.Lock()
defer fake.useChannelCreationPolicyAsAdminsMutex.Unlock()
fake.UseChannelCreationPolicyAsAdminsStub = nil
if fake.useChannelCreationPolicyAsAdminsReturnsOnCall == nil {
fake.useChannelCreationPolicyAsAdminsReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.useChannelCreationPolicyAsAdminsReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *OrdererCapabilities) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.consensusTypeMigrationMutex.RLock()
defer fake.consensusTypeMigrationMutex.RUnlock()
fake.expirationCheckMutex.RLock()
defer fake.expirationCheckMutex.RUnlock()
fake.predictableChannelTemplateMutex.RLock()
defer fake.predictableChannelTemplateMutex.RUnlock()
fake.resubmissionMutex.RLock()
defer fake.resubmissionMutex.RUnlock()
fake.supportedMutex.RLock()
defer fake.supportedMutex.RUnlock()
fake.useChannelCreationPolicyAsAdminsMutex.RLock()
defer fake.useChannelCreationPolicyAsAdminsMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *OrdererCapabilities) 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)
}
You can’t perform that action at this time.