msp.go

// Code generated by counterfeiter. DO NOT EDIT.
package mocks

import (
	"sync"

	"github.com/hyperledger/fabric-cli/pkg/fabric"
	"github.com/hyperledger/fabric-sdk-go/pkg/client/msp"
	mspa "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/msp"
)

type MSP struct {
	AddAffiliationStub        func(*msp.AffiliationRequest) (*msp.AffiliationResponse, error)
	addAffiliationMutex       sync.RWMutex
	addAffiliationArgsForCall []struct {
		arg1 *msp.AffiliationRequest
	}
	addAffiliationReturns struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	addAffiliationReturnsOnCall map[int]struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	CreateIdentityStub        func(*msp.IdentityRequest) (*msp.IdentityResponse, error)
	createIdentityMutex       sync.RWMutex
	createIdentityArgsForCall []struct {
		arg1 *msp.IdentityRequest
	}
	createIdentityReturns struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	createIdentityReturnsOnCall map[int]struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	CreateSigningIdentityStub        func(...mspa.SigningIdentityOption) (mspa.SigningIdentity, error)
	createSigningIdentityMutex       sync.RWMutex
	createSigningIdentityArgsForCall []struct {
		arg1 []mspa.SigningIdentityOption
	}
	createSigningIdentityReturns struct {
		result1 mspa.SigningIdentity
		result2 error
	}
	createSigningIdentityReturnsOnCall map[int]struct {
		result1 mspa.SigningIdentity
		result2 error
	}
	EnrollStub        func(string, ...msp.EnrollmentOption) error
	enrollMutex       sync.RWMutex
	enrollArgsForCall []struct {
		arg1 string
		arg2 []msp.EnrollmentOption
	}
	enrollReturns struct {
		result1 error
	}
	enrollReturnsOnCall map[int]struct {
		result1 error
	}
	GetAffiliationStub        func(string, ...msp.RequestOption) (*msp.AffiliationResponse, error)
	getAffiliationMutex       sync.RWMutex
	getAffiliationArgsForCall []struct {
		arg1 string
		arg2 []msp.RequestOption
	}
	getAffiliationReturns struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	getAffiliationReturnsOnCall map[int]struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	GetAllAffiliationsStub        func(...msp.RequestOption) (*msp.AffiliationResponse, error)
	getAllAffiliationsMutex       sync.RWMutex
	getAllAffiliationsArgsForCall []struct {
		arg1 []msp.RequestOption
	}
	getAllAffiliationsReturns struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	getAllAffiliationsReturnsOnCall map[int]struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	GetAllIdentitiesStub        func(...msp.RequestOption) ([]*msp.IdentityResponse, error)
	getAllIdentitiesMutex       sync.RWMutex
	getAllIdentitiesArgsForCall []struct {
		arg1 []msp.RequestOption
	}
	getAllIdentitiesReturns struct {
		result1 []*msp.IdentityResponse
		result2 error
	}
	getAllIdentitiesReturnsOnCall map[int]struct {
		result1 []*msp.IdentityResponse
		result2 error
	}
	GetCAInfoStub        func() (*msp.GetCAInfoResponse, error)
	getCAInfoMutex       sync.RWMutex
	getCAInfoArgsForCall []struct {
	}
	getCAInfoReturns struct {
		result1 *msp.GetCAInfoResponse
		result2 error
	}
	getCAInfoReturnsOnCall map[int]struct {
		result1 *msp.GetCAInfoResponse
		result2 error
	}
	GetIdentityStub        func(string, ...msp.RequestOption) (*msp.IdentityResponse, error)
	getIdentityMutex       sync.RWMutex
	getIdentityArgsForCall []struct {
		arg1 string
		arg2 []msp.RequestOption
	}
	getIdentityReturns struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	getIdentityReturnsOnCall map[int]struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	GetSigningIdentityStub        func(string) (mspa.SigningIdentity, error)
	getSigningIdentityMutex       sync.RWMutex
	getSigningIdentityArgsForCall []struct {
		arg1 string
	}
	getSigningIdentityReturns struct {
		result1 mspa.SigningIdentity
		result2 error
	}
	getSigningIdentityReturnsOnCall map[int]struct {
		result1 mspa.SigningIdentity
		result2 error
	}
	ModifyAffiliationStub        func(*msp.ModifyAffiliationRequest) (*msp.AffiliationResponse, error)
	modifyAffiliationMutex       sync.RWMutex
	modifyAffiliationArgsForCall []struct {
		arg1 *msp.ModifyAffiliationRequest
	}
	modifyAffiliationReturns struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	modifyAffiliationReturnsOnCall map[int]struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	ModifyIdentityStub        func(*msp.IdentityRequest) (*msp.IdentityResponse, error)
	modifyIdentityMutex       sync.RWMutex
	modifyIdentityArgsForCall []struct {
		arg1 *msp.IdentityRequest
	}
	modifyIdentityReturns struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	modifyIdentityReturnsOnCall map[int]struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	ReenrollStub        func(string, ...msp.EnrollmentOption) error
	reenrollMutex       sync.RWMutex
	reenrollArgsForCall []struct {
		arg1 string
		arg2 []msp.EnrollmentOption
	}
	reenrollReturns struct {
		result1 error
	}
	reenrollReturnsOnCall map[int]struct {
		result1 error
	}
	RegisterStub        func(*msp.RegistrationRequest) (string, error)
	registerMutex       sync.RWMutex
	registerArgsForCall []struct {
		arg1 *msp.RegistrationRequest
	}
	registerReturns struct {
		result1 string
		result2 error
	}
	registerReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	RemoveAffiliationStub        func(*msp.AffiliationRequest) (*msp.AffiliationResponse, error)
	removeAffiliationMutex       sync.RWMutex
	removeAffiliationArgsForCall []struct {
		arg1 *msp.AffiliationRequest
	}
	removeAffiliationReturns struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	removeAffiliationReturnsOnCall map[int]struct {
		result1 *msp.AffiliationResponse
		result2 error
	}
	RemoveIdentityStub        func(*msp.RemoveIdentityRequest) (*msp.IdentityResponse, error)
	removeIdentityMutex       sync.RWMutex
	removeIdentityArgsForCall []struct {
		arg1 *msp.RemoveIdentityRequest
	}
	removeIdentityReturns struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	removeIdentityReturnsOnCall map[int]struct {
		result1 *msp.IdentityResponse
		result2 error
	}
	RevokeStub        func(*msp.RevocationRequest) (*msp.RevocationResponse, error)
	revokeMutex       sync.RWMutex
	revokeArgsForCall []struct {
		arg1 *msp.RevocationRequest
	}
	revokeReturns struct {
		result1 *msp.RevocationResponse
		result2 error
	}
	revokeReturnsOnCall map[int]struct {
		result1 *msp.RevocationResponse
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *MSP) AddAffiliation(arg1 *msp.AffiliationRequest) (*msp.AffiliationResponse, error) {
	fake.addAffiliationMutex.Lock()
	ret, specificReturn := fake.addAffiliationReturnsOnCall[len(fake.addAffiliationArgsForCall)]
	fake.addAffiliationArgsForCall = append(fake.addAffiliationArgsForCall, struct {
		arg1 *msp.AffiliationRequest
	}{arg1})
	fake.recordInvocation("AddAffiliation", []interface{}{arg1})
	fake.addAffiliationMutex.Unlock()
	if fake.AddAffiliationStub != nil {
		return fake.AddAffiliationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.addAffiliationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) AddAffiliationCallCount() int {
	fake.addAffiliationMutex.RLock()
	defer fake.addAffiliationMutex.RUnlock()
	return len(fake.addAffiliationArgsForCall)
}

func (fake *MSP) AddAffiliationCalls(stub func(*msp.AffiliationRequest) (*msp.AffiliationResponse, error)) {
	fake.addAffiliationMutex.Lock()
	defer fake.addAffiliationMutex.Unlock()
	fake.AddAffiliationStub = stub
}

func (fake *MSP) AddAffiliationArgsForCall(i int) *msp.AffiliationRequest {
	fake.addAffiliationMutex.RLock()
	defer fake.addAffiliationMutex.RUnlock()
	argsForCall := fake.addAffiliationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) AddAffiliationReturns(result1 *msp.AffiliationResponse, result2 error) {
	fake.addAffiliationMutex.Lock()
	defer fake.addAffiliationMutex.Unlock()
	fake.AddAffiliationStub = nil
	fake.addAffiliationReturns = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) AddAffiliationReturnsOnCall(i int, result1 *msp.AffiliationResponse, result2 error) {
	fake.addAffiliationMutex.Lock()
	defer fake.addAffiliationMutex.Unlock()
	fake.AddAffiliationStub = nil
	if fake.addAffiliationReturnsOnCall == nil {
		fake.addAffiliationReturnsOnCall = make(map[int]struct {
			result1 *msp.AffiliationResponse
			result2 error
		})
	}
	fake.addAffiliationReturnsOnCall[i] = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) CreateIdentity(arg1 *msp.IdentityRequest) (*msp.IdentityResponse, error) {
	fake.createIdentityMutex.Lock()
	ret, specificReturn := fake.createIdentityReturnsOnCall[len(fake.createIdentityArgsForCall)]
	fake.createIdentityArgsForCall = append(fake.createIdentityArgsForCall, struct {
		arg1 *msp.IdentityRequest
	}{arg1})
	fake.recordInvocation("CreateIdentity", []interface{}{arg1})
	fake.createIdentityMutex.Unlock()
	if fake.CreateIdentityStub != nil {
		return fake.CreateIdentityStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) CreateIdentityCallCount() int {
	fake.createIdentityMutex.RLock()
	defer fake.createIdentityMutex.RUnlock()
	return len(fake.createIdentityArgsForCall)
}

func (fake *MSP) CreateIdentityCalls(stub func(*msp.IdentityRequest) (*msp.IdentityResponse, error)) {
	fake.createIdentityMutex.Lock()
	defer fake.createIdentityMutex.Unlock()
	fake.CreateIdentityStub = stub
}

func (fake *MSP) CreateIdentityArgsForCall(i int) *msp.IdentityRequest {
	fake.createIdentityMutex.RLock()
	defer fake.createIdentityMutex.RUnlock()
	argsForCall := fake.createIdentityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) CreateIdentityReturns(result1 *msp.IdentityResponse, result2 error) {
	fake.createIdentityMutex.Lock()
	defer fake.createIdentityMutex.Unlock()
	fake.CreateIdentityStub = nil
	fake.createIdentityReturns = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) CreateIdentityReturnsOnCall(i int, result1 *msp.IdentityResponse, result2 error) {
	fake.createIdentityMutex.Lock()
	defer fake.createIdentityMutex.Unlock()
	fake.CreateIdentityStub = nil
	if fake.createIdentityReturnsOnCall == nil {
		fake.createIdentityReturnsOnCall = make(map[int]struct {
			result1 *msp.IdentityResponse
			result2 error
		})
	}
	fake.createIdentityReturnsOnCall[i] = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) CreateSigningIdentity(arg1 ...mspa.SigningIdentityOption) (mspa.SigningIdentity, error) {
	fake.createSigningIdentityMutex.Lock()
	ret, specificReturn := fake.createSigningIdentityReturnsOnCall[len(fake.createSigningIdentityArgsForCall)]
	fake.createSigningIdentityArgsForCall = append(fake.createSigningIdentityArgsForCall, struct {
		arg1 []mspa.SigningIdentityOption
	}{arg1})
	fake.recordInvocation("CreateSigningIdentity", []interface{}{arg1})
	fake.createSigningIdentityMutex.Unlock()
	if fake.CreateSigningIdentityStub != nil {
		return fake.CreateSigningIdentityStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createSigningIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) CreateSigningIdentityCallCount() int {
	fake.createSigningIdentityMutex.RLock()
	defer fake.createSigningIdentityMutex.RUnlock()
	return len(fake.createSigningIdentityArgsForCall)
}

func (fake *MSP) CreateSigningIdentityCalls(stub func(...mspa.SigningIdentityOption) (mspa.SigningIdentity, error)) {
	fake.createSigningIdentityMutex.Lock()
	defer fake.createSigningIdentityMutex.Unlock()
	fake.CreateSigningIdentityStub = stub
}

func (fake *MSP) CreateSigningIdentityArgsForCall(i int) []mspa.SigningIdentityOption {
	fake.createSigningIdentityMutex.RLock()
	defer fake.createSigningIdentityMutex.RUnlock()
	argsForCall := fake.createSigningIdentityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) CreateSigningIdentityReturns(result1 mspa.SigningIdentity, result2 error) {
	fake.createSigningIdentityMutex.Lock()
	defer fake.createSigningIdentityMutex.Unlock()
	fake.CreateSigningIdentityStub = nil
	fake.createSigningIdentityReturns = struct {
		result1 mspa.SigningIdentity
		result2 error
	}{result1, result2}
}

func (fake *MSP) CreateSigningIdentityReturnsOnCall(i int, result1 mspa.SigningIdentity, result2 error) {
	fake.createSigningIdentityMutex.Lock()
	defer fake.createSigningIdentityMutex.Unlock()
	fake.CreateSigningIdentityStub = nil
	if fake.createSigningIdentityReturnsOnCall == nil {
		fake.createSigningIdentityReturnsOnCall = make(map[int]struct {
			result1 mspa.SigningIdentity
			result2 error
		})
	}
	fake.createSigningIdentityReturnsOnCall[i] = struct {
		result1 mspa.SigningIdentity
		result2 error
	}{result1, result2}
}

func (fake *MSP) Enroll(arg1 string, arg2 ...msp.EnrollmentOption) error {
	fake.enrollMutex.Lock()
	ret, specificReturn := fake.enrollReturnsOnCall[len(fake.enrollArgsForCall)]
	fake.enrollArgsForCall = append(fake.enrollArgsForCall, struct {
		arg1 string
		arg2 []msp.EnrollmentOption
	}{arg1, arg2})
	fake.recordInvocation("Enroll", []interface{}{arg1, arg2})
	fake.enrollMutex.Unlock()
	if fake.EnrollStub != nil {
		return fake.EnrollStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.enrollReturns
	return fakeReturns.result1
}

func (fake *MSP) EnrollCallCount() int {
	fake.enrollMutex.RLock()
	defer fake.enrollMutex.RUnlock()
	return len(fake.enrollArgsForCall)
}

func (fake *MSP) EnrollCalls(stub func(string, ...msp.EnrollmentOption) error) {
	fake.enrollMutex.Lock()
	defer fake.enrollMutex.Unlock()
	fake.EnrollStub = stub
}

func (fake *MSP) EnrollArgsForCall(i int) (string, []msp.EnrollmentOption) {
	fake.enrollMutex.RLock()
	defer fake.enrollMutex.RUnlock()
	argsForCall := fake.enrollArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *MSP) EnrollReturns(result1 error) {
	fake.enrollMutex.Lock()
	defer fake.enrollMutex.Unlock()
	fake.EnrollStub = nil
	fake.enrollReturns = struct {
		result1 error
	}{result1}
}

func (fake *MSP) EnrollReturnsOnCall(i int, result1 error) {
	fake.enrollMutex.Lock()
	defer fake.enrollMutex.Unlock()
	fake.EnrollStub = nil
	if fake.enrollReturnsOnCall == nil {
		fake.enrollReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.enrollReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *MSP) GetAffiliation(arg1 string, arg2 ...msp.RequestOption) (*msp.AffiliationResponse, error) {
	fake.getAffiliationMutex.Lock()
	ret, specificReturn := fake.getAffiliationReturnsOnCall[len(fake.getAffiliationArgsForCall)]
	fake.getAffiliationArgsForCall = append(fake.getAffiliationArgsForCall, struct {
		arg1 string
		arg2 []msp.RequestOption
	}{arg1, arg2})
	fake.recordInvocation("GetAffiliation", []interface{}{arg1, arg2})
	fake.getAffiliationMutex.Unlock()
	if fake.GetAffiliationStub != nil {
		return fake.GetAffiliationStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAffiliationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetAffiliationCallCount() int {
	fake.getAffiliationMutex.RLock()
	defer fake.getAffiliationMutex.RUnlock()
	return len(fake.getAffiliationArgsForCall)
}

func (fake *MSP) GetAffiliationCalls(stub func(string, ...msp.RequestOption) (*msp.AffiliationResponse, error)) {
	fake.getAffiliationMutex.Lock()
	defer fake.getAffiliationMutex.Unlock()
	fake.GetAffiliationStub = stub
}

func (fake *MSP) GetAffiliationArgsForCall(i int) (string, []msp.RequestOption) {
	fake.getAffiliationMutex.RLock()
	defer fake.getAffiliationMutex.RUnlock()
	argsForCall := fake.getAffiliationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *MSP) GetAffiliationReturns(result1 *msp.AffiliationResponse, result2 error) {
	fake.getAffiliationMutex.Lock()
	defer fake.getAffiliationMutex.Unlock()
	fake.GetAffiliationStub = nil
	fake.getAffiliationReturns = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetAffiliationReturnsOnCall(i int, result1 *msp.AffiliationResponse, result2 error) {
	fake.getAffiliationMutex.Lock()
	defer fake.getAffiliationMutex.Unlock()
	fake.GetAffiliationStub = nil
	if fake.getAffiliationReturnsOnCall == nil {
		fake.getAffiliationReturnsOnCall = make(map[int]struct {
			result1 *msp.AffiliationResponse
			result2 error
		})
	}
	fake.getAffiliationReturnsOnCall[i] = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetAllAffiliations(arg1 ...msp.RequestOption) (*msp.AffiliationResponse, error) {
	fake.getAllAffiliationsMutex.Lock()
	ret, specificReturn := fake.getAllAffiliationsReturnsOnCall[len(fake.getAllAffiliationsArgsForCall)]
	fake.getAllAffiliationsArgsForCall = append(fake.getAllAffiliationsArgsForCall, struct {
		arg1 []msp.RequestOption
	}{arg1})
	fake.recordInvocation("GetAllAffiliations", []interface{}{arg1})
	fake.getAllAffiliationsMutex.Unlock()
	if fake.GetAllAffiliationsStub != nil {
		return fake.GetAllAffiliationsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAllAffiliationsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetAllAffiliationsCallCount() int {
	fake.getAllAffiliationsMutex.RLock()
	defer fake.getAllAffiliationsMutex.RUnlock()
	return len(fake.getAllAffiliationsArgsForCall)
}

func (fake *MSP) GetAllAffiliationsCalls(stub func(...msp.RequestOption) (*msp.AffiliationResponse, error)) {
	fake.getAllAffiliationsMutex.Lock()
	defer fake.getAllAffiliationsMutex.Unlock()
	fake.GetAllAffiliationsStub = stub
}

func (fake *MSP) GetAllAffiliationsArgsForCall(i int) []msp.RequestOption {
	fake.getAllAffiliationsMutex.RLock()
	defer fake.getAllAffiliationsMutex.RUnlock()
	argsForCall := fake.getAllAffiliationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) GetAllAffiliationsReturns(result1 *msp.AffiliationResponse, result2 error) {
	fake.getAllAffiliationsMutex.Lock()
	defer fake.getAllAffiliationsMutex.Unlock()
	fake.GetAllAffiliationsStub = nil
	fake.getAllAffiliationsReturns = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetAllAffiliationsReturnsOnCall(i int, result1 *msp.AffiliationResponse, result2 error) {
	fake.getAllAffiliationsMutex.Lock()
	defer fake.getAllAffiliationsMutex.Unlock()
	fake.GetAllAffiliationsStub = nil
	if fake.getAllAffiliationsReturnsOnCall == nil {
		fake.getAllAffiliationsReturnsOnCall = make(map[int]struct {
			result1 *msp.AffiliationResponse
			result2 error
		})
	}
	fake.getAllAffiliationsReturnsOnCall[i] = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetAllIdentities(arg1 ...msp.RequestOption) ([]*msp.IdentityResponse, error) {
	fake.getAllIdentitiesMutex.Lock()
	ret, specificReturn := fake.getAllIdentitiesReturnsOnCall[len(fake.getAllIdentitiesArgsForCall)]
	fake.getAllIdentitiesArgsForCall = append(fake.getAllIdentitiesArgsForCall, struct {
		arg1 []msp.RequestOption
	}{arg1})
	fake.recordInvocation("GetAllIdentities", []interface{}{arg1})
	fake.getAllIdentitiesMutex.Unlock()
	if fake.GetAllIdentitiesStub != nil {
		return fake.GetAllIdentitiesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAllIdentitiesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetAllIdentitiesCallCount() int {
	fake.getAllIdentitiesMutex.RLock()
	defer fake.getAllIdentitiesMutex.RUnlock()
	return len(fake.getAllIdentitiesArgsForCall)
}

func (fake *MSP) GetAllIdentitiesCalls(stub func(...msp.RequestOption) ([]*msp.IdentityResponse, error)) {
	fake.getAllIdentitiesMutex.Lock()
	defer fake.getAllIdentitiesMutex.Unlock()
	fake.GetAllIdentitiesStub = stub
}

func (fake *MSP) GetAllIdentitiesArgsForCall(i int) []msp.RequestOption {
	fake.getAllIdentitiesMutex.RLock()
	defer fake.getAllIdentitiesMutex.RUnlock()
	argsForCall := fake.getAllIdentitiesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) GetAllIdentitiesReturns(result1 []*msp.IdentityResponse, result2 error) {
	fake.getAllIdentitiesMutex.Lock()
	defer fake.getAllIdentitiesMutex.Unlock()
	fake.GetAllIdentitiesStub = nil
	fake.getAllIdentitiesReturns = struct {
		result1 []*msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetAllIdentitiesReturnsOnCall(i int, result1 []*msp.IdentityResponse, result2 error) {
	fake.getAllIdentitiesMutex.Lock()
	defer fake.getAllIdentitiesMutex.Unlock()
	fake.GetAllIdentitiesStub = nil
	if fake.getAllIdentitiesReturnsOnCall == nil {
		fake.getAllIdentitiesReturnsOnCall = make(map[int]struct {
			result1 []*msp.IdentityResponse
			result2 error
		})
	}
	fake.getAllIdentitiesReturnsOnCall[i] = struct {
		result1 []*msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetCAInfo() (*msp.GetCAInfoResponse, error) {
	fake.getCAInfoMutex.Lock()
	ret, specificReturn := fake.getCAInfoReturnsOnCall[len(fake.getCAInfoArgsForCall)]
	fake.getCAInfoArgsForCall = append(fake.getCAInfoArgsForCall, struct {
	}{})
	fake.recordInvocation("GetCAInfo", []interface{}{})
	fake.getCAInfoMutex.Unlock()
	if fake.GetCAInfoStub != nil {
		return fake.GetCAInfoStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getCAInfoReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetCAInfoCallCount() int {
	fake.getCAInfoMutex.RLock()
	defer fake.getCAInfoMutex.RUnlock()
	return len(fake.getCAInfoArgsForCall)
}

func (fake *MSP) GetCAInfoCalls(stub func() (*msp.GetCAInfoResponse, error)) {
	fake.getCAInfoMutex.Lock()
	defer fake.getCAInfoMutex.Unlock()
	fake.GetCAInfoStub = stub
}

func (fake *MSP) GetCAInfoReturns(result1 *msp.GetCAInfoResponse, result2 error) {
	fake.getCAInfoMutex.Lock()
	defer fake.getCAInfoMutex.Unlock()
	fake.GetCAInfoStub = nil
	fake.getCAInfoReturns = struct {
		result1 *msp.GetCAInfoResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetCAInfoReturnsOnCall(i int, result1 *msp.GetCAInfoResponse, result2 error) {
	fake.getCAInfoMutex.Lock()
	defer fake.getCAInfoMutex.Unlock()
	fake.GetCAInfoStub = nil
	if fake.getCAInfoReturnsOnCall == nil {
		fake.getCAInfoReturnsOnCall = make(map[int]struct {
			result1 *msp.GetCAInfoResponse
			result2 error
		})
	}
	fake.getCAInfoReturnsOnCall[i] = struct {
		result1 *msp.GetCAInfoResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetIdentity(arg1 string, arg2 ...msp.RequestOption) (*msp.IdentityResponse, error) {
	fake.getIdentityMutex.Lock()
	ret, specificReturn := fake.getIdentityReturnsOnCall[len(fake.getIdentityArgsForCall)]
	fake.getIdentityArgsForCall = append(fake.getIdentityArgsForCall, struct {
		arg1 string
		arg2 []msp.RequestOption
	}{arg1, arg2})
	fake.recordInvocation("GetIdentity", []interface{}{arg1, arg2})
	fake.getIdentityMutex.Unlock()
	if fake.GetIdentityStub != nil {
		return fake.GetIdentityStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetIdentityCallCount() int {
	fake.getIdentityMutex.RLock()
	defer fake.getIdentityMutex.RUnlock()
	return len(fake.getIdentityArgsForCall)
}

func (fake *MSP) GetIdentityCalls(stub func(string, ...msp.RequestOption) (*msp.IdentityResponse, error)) {
	fake.getIdentityMutex.Lock()
	defer fake.getIdentityMutex.Unlock()
	fake.GetIdentityStub = stub
}

func (fake *MSP) GetIdentityArgsForCall(i int) (string, []msp.RequestOption) {
	fake.getIdentityMutex.RLock()
	defer fake.getIdentityMutex.RUnlock()
	argsForCall := fake.getIdentityArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *MSP) GetIdentityReturns(result1 *msp.IdentityResponse, result2 error) {
	fake.getIdentityMutex.Lock()
	defer fake.getIdentityMutex.Unlock()
	fake.GetIdentityStub = nil
	fake.getIdentityReturns = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetIdentityReturnsOnCall(i int, result1 *msp.IdentityResponse, result2 error) {
	fake.getIdentityMutex.Lock()
	defer fake.getIdentityMutex.Unlock()
	fake.GetIdentityStub = nil
	if fake.getIdentityReturnsOnCall == nil {
		fake.getIdentityReturnsOnCall = make(map[int]struct {
			result1 *msp.IdentityResponse
			result2 error
		})
	}
	fake.getIdentityReturnsOnCall[i] = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetSigningIdentity(arg1 string) (mspa.SigningIdentity, error) {
	fake.getSigningIdentityMutex.Lock()
	ret, specificReturn := fake.getSigningIdentityReturnsOnCall[len(fake.getSigningIdentityArgsForCall)]
	fake.getSigningIdentityArgsForCall = append(fake.getSigningIdentityArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSigningIdentity", []interface{}{arg1})
	fake.getSigningIdentityMutex.Unlock()
	if fake.GetSigningIdentityStub != nil {
		return fake.GetSigningIdentityStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getSigningIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) GetSigningIdentityCallCount() int {
	fake.getSigningIdentityMutex.RLock()
	defer fake.getSigningIdentityMutex.RUnlock()
	return len(fake.getSigningIdentityArgsForCall)
}

func (fake *MSP) GetSigningIdentityCalls(stub func(string) (mspa.SigningIdentity, error)) {
	fake.getSigningIdentityMutex.Lock()
	defer fake.getSigningIdentityMutex.Unlock()
	fake.GetSigningIdentityStub = stub
}

func (fake *MSP) GetSigningIdentityArgsForCall(i int) string {
	fake.getSigningIdentityMutex.RLock()
	defer fake.getSigningIdentityMutex.RUnlock()
	argsForCall := fake.getSigningIdentityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) GetSigningIdentityReturns(result1 mspa.SigningIdentity, result2 error) {
	fake.getSigningIdentityMutex.Lock()
	defer fake.getSigningIdentityMutex.Unlock()
	fake.GetSigningIdentityStub = nil
	fake.getSigningIdentityReturns = struct {
		result1 mspa.SigningIdentity
		result2 error
	}{result1, result2}
}

func (fake *MSP) GetSigningIdentityReturnsOnCall(i int, result1 mspa.SigningIdentity, result2 error) {
	fake.getSigningIdentityMutex.Lock()
	defer fake.getSigningIdentityMutex.Unlock()
	fake.GetSigningIdentityStub = nil
	if fake.getSigningIdentityReturnsOnCall == nil {
		fake.getSigningIdentityReturnsOnCall = make(map[int]struct {
			result1 mspa.SigningIdentity
			result2 error
		})
	}
	fake.getSigningIdentityReturnsOnCall[i] = struct {
		result1 mspa.SigningIdentity
		result2 error
	}{result1, result2}
}

func (fake *MSP) ModifyAffiliation(arg1 *msp.ModifyAffiliationRequest) (*msp.AffiliationResponse, error) {
	fake.modifyAffiliationMutex.Lock()
	ret, specificReturn := fake.modifyAffiliationReturnsOnCall[len(fake.modifyAffiliationArgsForCall)]
	fake.modifyAffiliationArgsForCall = append(fake.modifyAffiliationArgsForCall, struct {
		arg1 *msp.ModifyAffiliationRequest
	}{arg1})
	fake.recordInvocation("ModifyAffiliation", []interface{}{arg1})
	fake.modifyAffiliationMutex.Unlock()
	if fake.ModifyAffiliationStub != nil {
		return fake.ModifyAffiliationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.modifyAffiliationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) ModifyAffiliationCallCount() int {
	fake.modifyAffiliationMutex.RLock()
	defer fake.modifyAffiliationMutex.RUnlock()
	return len(fake.modifyAffiliationArgsForCall)
}

func (fake *MSP) ModifyAffiliationCalls(stub func(*msp.ModifyAffiliationRequest) (*msp.AffiliationResponse, error)) {
	fake.modifyAffiliationMutex.Lock()
	defer fake.modifyAffiliationMutex.Unlock()
	fake.ModifyAffiliationStub = stub
}

func (fake *MSP) ModifyAffiliationArgsForCall(i int) *msp.ModifyAffiliationRequest {
	fake.modifyAffiliationMutex.RLock()
	defer fake.modifyAffiliationMutex.RUnlock()
	argsForCall := fake.modifyAffiliationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) ModifyAffiliationReturns(result1 *msp.AffiliationResponse, result2 error) {
	fake.modifyAffiliationMutex.Lock()
	defer fake.modifyAffiliationMutex.Unlock()
	fake.ModifyAffiliationStub = nil
	fake.modifyAffiliationReturns = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) ModifyAffiliationReturnsOnCall(i int, result1 *msp.AffiliationResponse, result2 error) {
	fake.modifyAffiliationMutex.Lock()
	defer fake.modifyAffiliationMutex.Unlock()
	fake.ModifyAffiliationStub = nil
	if fake.modifyAffiliationReturnsOnCall == nil {
		fake.modifyAffiliationReturnsOnCall = make(map[int]struct {
			result1 *msp.AffiliationResponse
			result2 error
		})
	}
	fake.modifyAffiliationReturnsOnCall[i] = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) ModifyIdentity(arg1 *msp.IdentityRequest) (*msp.IdentityResponse, error) {
	fake.modifyIdentityMutex.Lock()
	ret, specificReturn := fake.modifyIdentityReturnsOnCall[len(fake.modifyIdentityArgsForCall)]
	fake.modifyIdentityArgsForCall = append(fake.modifyIdentityArgsForCall, struct {
		arg1 *msp.IdentityRequest
	}{arg1})
	fake.recordInvocation("ModifyIdentity", []interface{}{arg1})
	fake.modifyIdentityMutex.Unlock()
	if fake.ModifyIdentityStub != nil {
		return fake.ModifyIdentityStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.modifyIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) ModifyIdentityCallCount() int {
	fake.modifyIdentityMutex.RLock()
	defer fake.modifyIdentityMutex.RUnlock()
	return len(fake.modifyIdentityArgsForCall)
}

func (fake *MSP) ModifyIdentityCalls(stub func(*msp.IdentityRequest) (*msp.IdentityResponse, error)) {
	fake.modifyIdentityMutex.Lock()
	defer fake.modifyIdentityMutex.Unlock()
	fake.ModifyIdentityStub = stub
}

func (fake *MSP) ModifyIdentityArgsForCall(i int) *msp.IdentityRequest {
	fake.modifyIdentityMutex.RLock()
	defer fake.modifyIdentityMutex.RUnlock()
	argsForCall := fake.modifyIdentityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) ModifyIdentityReturns(result1 *msp.IdentityResponse, result2 error) {
	fake.modifyIdentityMutex.Lock()
	defer fake.modifyIdentityMutex.Unlock()
	fake.ModifyIdentityStub = nil
	fake.modifyIdentityReturns = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) ModifyIdentityReturnsOnCall(i int, result1 *msp.IdentityResponse, result2 error) {
	fake.modifyIdentityMutex.Lock()
	defer fake.modifyIdentityMutex.Unlock()
	fake.ModifyIdentityStub = nil
	if fake.modifyIdentityReturnsOnCall == nil {
		fake.modifyIdentityReturnsOnCall = make(map[int]struct {
			result1 *msp.IdentityResponse
			result2 error
		})
	}
	fake.modifyIdentityReturnsOnCall[i] = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) Reenroll(arg1 string, arg2 ...msp.EnrollmentOption) error {
	fake.reenrollMutex.Lock()
	ret, specificReturn := fake.reenrollReturnsOnCall[len(fake.reenrollArgsForCall)]
	fake.reenrollArgsForCall = append(fake.reenrollArgsForCall, struct {
		arg1 string
		arg2 []msp.EnrollmentOption
	}{arg1, arg2})
	fake.recordInvocation("Reenroll", []interface{}{arg1, arg2})
	fake.reenrollMutex.Unlock()
	if fake.ReenrollStub != nil {
		return fake.ReenrollStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.reenrollReturns
	return fakeReturns.result1
}

func (fake *MSP) ReenrollCallCount() int {
	fake.reenrollMutex.RLock()
	defer fake.reenrollMutex.RUnlock()
	return len(fake.reenrollArgsForCall)
}

func (fake *MSP) ReenrollCalls(stub func(string, ...msp.EnrollmentOption) error) {
	fake.reenrollMutex.Lock()
	defer fake.reenrollMutex.Unlock()
	fake.ReenrollStub = stub
}

func (fake *MSP) ReenrollArgsForCall(i int) (string, []msp.EnrollmentOption) {
	fake.reenrollMutex.RLock()
	defer fake.reenrollMutex.RUnlock()
	argsForCall := fake.reenrollArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *MSP) ReenrollReturns(result1 error) {
	fake.reenrollMutex.Lock()
	defer fake.reenrollMutex.Unlock()
	fake.ReenrollStub = nil
	fake.reenrollReturns = struct {
		result1 error
	}{result1}
}

func (fake *MSP) ReenrollReturnsOnCall(i int, result1 error) {
	fake.reenrollMutex.Lock()
	defer fake.reenrollMutex.Unlock()
	fake.ReenrollStub = nil
	if fake.reenrollReturnsOnCall == nil {
		fake.reenrollReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.reenrollReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *MSP) Register(arg1 *msp.RegistrationRequest) (string, error) {
	fake.registerMutex.Lock()
	ret, specificReturn := fake.registerReturnsOnCall[len(fake.registerArgsForCall)]
	fake.registerArgsForCall = append(fake.registerArgsForCall, struct {
		arg1 *msp.RegistrationRequest
	}{arg1})
	fake.recordInvocation("Register", []interface{}{arg1})
	fake.registerMutex.Unlock()
	if fake.RegisterStub != nil {
		return fake.RegisterStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.registerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) RegisterCallCount() int {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	return len(fake.registerArgsForCall)
}

func (fake *MSP) RegisterCalls(stub func(*msp.RegistrationRequest) (string, error)) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = stub
}

func (fake *MSP) RegisterArgsForCall(i int) *msp.RegistrationRequest {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	argsForCall := fake.registerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) RegisterReturns(result1 string, result2 error) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = nil
	fake.registerReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *MSP) RegisterReturnsOnCall(i int, result1 string, result2 error) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = nil
	if fake.registerReturnsOnCall == nil {
		fake.registerReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.registerReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *MSP) RemoveAffiliation(arg1 *msp.AffiliationRequest) (*msp.AffiliationResponse, error) {
	fake.removeAffiliationMutex.Lock()
	ret, specificReturn := fake.removeAffiliationReturnsOnCall[len(fake.removeAffiliationArgsForCall)]
	fake.removeAffiliationArgsForCall = append(fake.removeAffiliationArgsForCall, struct {
		arg1 *msp.AffiliationRequest
	}{arg1})
	fake.recordInvocation("RemoveAffiliation", []interface{}{arg1})
	fake.removeAffiliationMutex.Unlock()
	if fake.RemoveAffiliationStub != nil {
		return fake.RemoveAffiliationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.removeAffiliationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) RemoveAffiliationCallCount() int {
	fake.removeAffiliationMutex.RLock()
	defer fake.removeAffiliationMutex.RUnlock()
	return len(fake.removeAffiliationArgsForCall)
}

func (fake *MSP) RemoveAffiliationCalls(stub func(*msp.AffiliationRequest) (*msp.AffiliationResponse, error)) {
	fake.removeAffiliationMutex.Lock()
	defer fake.removeAffiliationMutex.Unlock()
	fake.RemoveAffiliationStub = stub
}

func (fake *MSP) RemoveAffiliationArgsForCall(i int) *msp.AffiliationRequest {
	fake.removeAffiliationMutex.RLock()
	defer fake.removeAffiliationMutex.RUnlock()
	argsForCall := fake.removeAffiliationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) RemoveAffiliationReturns(result1 *msp.AffiliationResponse, result2 error) {
	fake.removeAffiliationMutex.Lock()
	defer fake.removeAffiliationMutex.Unlock()
	fake.RemoveAffiliationStub = nil
	fake.removeAffiliationReturns = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) RemoveAffiliationReturnsOnCall(i int, result1 *msp.AffiliationResponse, result2 error) {
	fake.removeAffiliationMutex.Lock()
	defer fake.removeAffiliationMutex.Unlock()
	fake.RemoveAffiliationStub = nil
	if fake.removeAffiliationReturnsOnCall == nil {
		fake.removeAffiliationReturnsOnCall = make(map[int]struct {
			result1 *msp.AffiliationResponse
			result2 error
		})
	}
	fake.removeAffiliationReturnsOnCall[i] = struct {
		result1 *msp.AffiliationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) RemoveIdentity(arg1 *msp.RemoveIdentityRequest) (*msp.IdentityResponse, error) {
	fake.removeIdentityMutex.Lock()
	ret, specificReturn := fake.removeIdentityReturnsOnCall[len(fake.removeIdentityArgsForCall)]
	fake.removeIdentityArgsForCall = append(fake.removeIdentityArgsForCall, struct {
		arg1 *msp.RemoveIdentityRequest
	}{arg1})
	fake.recordInvocation("RemoveIdentity", []interface{}{arg1})
	fake.removeIdentityMutex.Unlock()
	if fake.RemoveIdentityStub != nil {
		return fake.RemoveIdentityStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.removeIdentityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) RemoveIdentityCallCount() int {
	fake.removeIdentityMutex.RLock()
	defer fake.removeIdentityMutex.RUnlock()
	return len(fake.removeIdentityArgsForCall)
}

func (fake *MSP) RemoveIdentityCalls(stub func(*msp.RemoveIdentityRequest) (*msp.IdentityResponse, error)) {
	fake.removeIdentityMutex.Lock()
	defer fake.removeIdentityMutex.Unlock()
	fake.RemoveIdentityStub = stub
}

func (fake *MSP) RemoveIdentityArgsForCall(i int) *msp.RemoveIdentityRequest {
	fake.removeIdentityMutex.RLock()
	defer fake.removeIdentityMutex.RUnlock()
	argsForCall := fake.removeIdentityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) RemoveIdentityReturns(result1 *msp.IdentityResponse, result2 error) {
	fake.removeIdentityMutex.Lock()
	defer fake.removeIdentityMutex.Unlock()
	fake.RemoveIdentityStub = nil
	fake.removeIdentityReturns = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) RemoveIdentityReturnsOnCall(i int, result1 *msp.IdentityResponse, result2 error) {
	fake.removeIdentityMutex.Lock()
	defer fake.removeIdentityMutex.Unlock()
	fake.RemoveIdentityStub = nil
	if fake.removeIdentityReturnsOnCall == nil {
		fake.removeIdentityReturnsOnCall = make(map[int]struct {
			result1 *msp.IdentityResponse
			result2 error
		})
	}
	fake.removeIdentityReturnsOnCall[i] = struct {
		result1 *msp.IdentityResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) Revoke(arg1 *msp.RevocationRequest) (*msp.RevocationResponse, error) {
	fake.revokeMutex.Lock()
	ret, specificReturn := fake.revokeReturnsOnCall[len(fake.revokeArgsForCall)]
	fake.revokeArgsForCall = append(fake.revokeArgsForCall, struct {
		arg1 *msp.RevocationRequest
	}{arg1})
	fake.recordInvocation("Revoke", []interface{}{arg1})
	fake.revokeMutex.Unlock()
	if fake.RevokeStub != nil {
		return fake.RevokeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.revokeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *MSP) RevokeCallCount() int {
	fake.revokeMutex.RLock()
	defer fake.revokeMutex.RUnlock()
	return len(fake.revokeArgsForCall)
}

func (fake *MSP) RevokeCalls(stub func(*msp.RevocationRequest) (*msp.RevocationResponse, error)) {
	fake.revokeMutex.Lock()
	defer fake.revokeMutex.Unlock()
	fake.RevokeStub = stub
}

func (fake *MSP) RevokeArgsForCall(i int) *msp.RevocationRequest {
	fake.revokeMutex.RLock()
	defer fake.revokeMutex.RUnlock()
	argsForCall := fake.revokeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *MSP) RevokeReturns(result1 *msp.RevocationResponse, result2 error) {
	fake.revokeMutex.Lock()
	defer fake.revokeMutex.Unlock()
	fake.RevokeStub = nil
	fake.revokeReturns = struct {
		result1 *msp.RevocationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) RevokeReturnsOnCall(i int, result1 *msp.RevocationResponse, result2 error) {
	fake.revokeMutex.Lock()
	defer fake.revokeMutex.Unlock()
	fake.RevokeStub = nil
	if fake.revokeReturnsOnCall == nil {
		fake.revokeReturnsOnCall = make(map[int]struct {
			result1 *msp.RevocationResponse
			result2 error
		})
	}
	fake.revokeReturnsOnCall[i] = struct {
		result1 *msp.RevocationResponse
		result2 error
	}{result1, result2}
}

func (fake *MSP) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.addAffiliationMutex.RLock()
	defer fake.addAffiliationMutex.RUnlock()
	fake.createIdentityMutex.RLock()
	defer fake.createIdentityMutex.RUnlock()
	fake.createSigningIdentityMutex.RLock()
	defer fake.createSigningIdentityMutex.RUnlock()
	fake.enrollMutex.RLock()
	defer fake.enrollMutex.RUnlock()
	fake.getAffiliationMutex.RLock()
	defer fake.getAffiliationMutex.RUnlock()
	fake.getAllAffiliationsMutex.RLock()
	defer fake.getAllAffiliationsMutex.RUnlock()
	fake.getAllIdentitiesMutex.RLock()
	defer fake.getAllIdentitiesMutex.RUnlock()
	fake.getCAInfoMutex.RLock()
	defer fake.getCAInfoMutex.RUnlock()
	fake.getIdentityMutex.RLock()
	defer fake.getIdentityMutex.RUnlock()
	fake.getSigningIdentityMutex.RLock()
	defer fake.getSigningIdentityMutex.RUnlock()
	fake.modifyAffiliationMutex.RLock()
	defer fake.modifyAffiliationMutex.RUnlock()
	fake.modifyIdentityMutex.RLock()
	defer fake.modifyIdentityMutex.RUnlock()
	fake.reenrollMutex.RLock()
	defer fake.reenrollMutex.RUnlock()
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	fake.removeAffiliationMutex.RLock()
	defer fake.removeAffiliationMutex.RUnlock()
	fake.removeIdentityMutex.RLock()
	defer fake.removeIdentityMutex.RUnlock()
	fake.revokeMutex.RLock()
	defer fake.revokeMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *MSP) 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 _ fabric.MSP = new(MSP)