github.com/IBM-Blockchain/fabric-operator@v1.0.4/pkg/initializer/ca/mocks/config.go

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

import (
	"sync"

	v1 "github.com/IBM-Blockchain/fabric-operator/pkg/apis/ca/v1"
	initializer "github.com/IBM-Blockchain/fabric-operator/pkg/initializer/ca"
	"github.com/IBM-Blockchain/fabric-operator/pkg/initializer/ca/config"
)

type CAConfig struct {
	GetHomeDirStub        func() string
	getHomeDirMutex       sync.RWMutex
	getHomeDirArgsForCall []struct {
	}
	getHomeDirReturns struct {
		result1 string
	}
	getHomeDirReturnsOnCall map[int]struct {
		result1 string
	}
	GetServerConfigStub        func() *v1.ServerConfig
	getServerConfigMutex       sync.RWMutex
	getServerConfigArgsForCall []struct {
	}
	getServerConfigReturns struct {
		result1 *v1.ServerConfig
	}
	getServerConfigReturnsOnCall map[int]struct {
		result1 *v1.ServerConfig
	}
	ParseCABlockStub        func() (map[string][]byte, error)
	parseCABlockMutex       sync.RWMutex
	parseCABlockArgsForCall []struct {
	}
	parseCABlockReturns struct {
		result1 map[string][]byte
		result2 error
	}
	parseCABlockReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	ParseDBBlockStub        func() (map[string][]byte, error)
	parseDBBlockMutex       sync.RWMutex
	parseDBBlockArgsForCall []struct {
	}
	parseDBBlockReturns struct {
		result1 map[string][]byte
		result2 error
	}
	parseDBBlockReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	ParseIntermediateBlockStub        func() (map[string][]byte, error)
	parseIntermediateBlockMutex       sync.RWMutex
	parseIntermediateBlockArgsForCall []struct {
	}
	parseIntermediateBlockReturns struct {
		result1 map[string][]byte
		result2 error
	}
	parseIntermediateBlockReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	ParseOperationsBlockStub        func() (map[string][]byte, error)
	parseOperationsBlockMutex       sync.RWMutex
	parseOperationsBlockArgsForCall []struct {
	}
	parseOperationsBlockReturns struct {
		result1 map[string][]byte
		result2 error
	}
	parseOperationsBlockReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	ParseTLSBlockStub        func() (map[string][]byte, error)
	parseTLSBlockMutex       sync.RWMutex
	parseTLSBlockArgsForCall []struct {
	}
	parseTLSBlockReturns struct {
		result1 map[string][]byte
		result2 error
	}
	parseTLSBlockReturnsOnCall map[int]struct {
		result1 map[string][]byte
		result2 error
	}
	SetMountPathsStub        func(config.Type)
	setMountPathsMutex       sync.RWMutex
	setMountPathsArgsForCall []struct {
		arg1 config.Type
	}
	SetServerConfigStub        func(*v1.ServerConfig)
	setServerConfigMutex       sync.RWMutex
	setServerConfigArgsForCall []struct {
		arg1 *v1.ServerConfig
	}
	SetUpdateStub        func(bool)
	setUpdateMutex       sync.RWMutex
	setUpdateArgsForCall []struct {
		arg1 bool
	}
	UsingPKCS11Stub        func() bool
	usingPKCS11Mutex       sync.RWMutex
	usingPKCS11ArgsForCall []struct {
	}
	usingPKCS11Returns struct {
		result1 bool
	}
	usingPKCS11ReturnsOnCall map[int]struct {
		result1 bool
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *CAConfig) GetHomeDir() string {
	fake.getHomeDirMutex.Lock()
	ret, specificReturn := fake.getHomeDirReturnsOnCall[len(fake.getHomeDirArgsForCall)]
	fake.getHomeDirArgsForCall = append(fake.getHomeDirArgsForCall, struct {
	}{})
	stub := fake.GetHomeDirStub
	fakeReturns := fake.getHomeDirReturns
	fake.recordInvocation("GetHomeDir", []interface{}{})
	fake.getHomeDirMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *CAConfig) GetHomeDirCallCount() int {
	fake.getHomeDirMutex.RLock()
	defer fake.getHomeDirMutex.RUnlock()
	return len(fake.getHomeDirArgsForCall)
}

func (fake *CAConfig) GetHomeDirCalls(stub func() string) {
	fake.getHomeDirMutex.Lock()
	defer fake.getHomeDirMutex.Unlock()
	fake.GetHomeDirStub = stub
}

func (fake *CAConfig) GetHomeDirReturns(result1 string) {
	fake.getHomeDirMutex.Lock()
	defer fake.getHomeDirMutex.Unlock()
	fake.GetHomeDirStub = nil
	fake.getHomeDirReturns = struct {
		result1 string
	}{result1}
}

func (fake *CAConfig) GetHomeDirReturnsOnCall(i int, result1 string) {
	fake.getHomeDirMutex.Lock()
	defer fake.getHomeDirMutex.Unlock()
	fake.GetHomeDirStub = nil
	if fake.getHomeDirReturnsOnCall == nil {
		fake.getHomeDirReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.getHomeDirReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *CAConfig) GetServerConfig() *v1.ServerConfig {
	fake.getServerConfigMutex.Lock()
	ret, specificReturn := fake.getServerConfigReturnsOnCall[len(fake.getServerConfigArgsForCall)]
	fake.getServerConfigArgsForCall = append(fake.getServerConfigArgsForCall, struct {
	}{})
	stub := fake.GetServerConfigStub
	fakeReturns := fake.getServerConfigReturns
	fake.recordInvocation("GetServerConfig", []interface{}{})
	fake.getServerConfigMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *CAConfig) GetServerConfigCallCount() int {
	fake.getServerConfigMutex.RLock()
	defer fake.getServerConfigMutex.RUnlock()
	return len(fake.getServerConfigArgsForCall)
}

func (fake *CAConfig) GetServerConfigCalls(stub func() *v1.ServerConfig) {
	fake.getServerConfigMutex.Lock()
	defer fake.getServerConfigMutex.Unlock()
	fake.GetServerConfigStub = stub
}

func (fake *CAConfig) GetServerConfigReturns(result1 *v1.ServerConfig) {
	fake.getServerConfigMutex.Lock()
	defer fake.getServerConfigMutex.Unlock()
	fake.GetServerConfigStub = nil
	fake.getServerConfigReturns = struct {
		result1 *v1.ServerConfig
	}{result1}
}

func (fake *CAConfig) GetServerConfigReturnsOnCall(i int, result1 *v1.ServerConfig) {
	fake.getServerConfigMutex.Lock()
	defer fake.getServerConfigMutex.Unlock()
	fake.GetServerConfigStub = nil
	if fake.getServerConfigReturnsOnCall == nil {
		fake.getServerConfigReturnsOnCall = make(map[int]struct {
			result1 *v1.ServerConfig
		})
	}
	fake.getServerConfigReturnsOnCall[i] = struct {
		result1 *v1.ServerConfig
	}{result1}
}

func (fake *CAConfig) ParseCABlock() (map[string][]byte, error) {
	fake.parseCABlockMutex.Lock()
	ret, specificReturn := fake.parseCABlockReturnsOnCall[len(fake.parseCABlockArgsForCall)]
	fake.parseCABlockArgsForCall = append(fake.parseCABlockArgsForCall, struct {
	}{})
	stub := fake.ParseCABlockStub
	fakeReturns := fake.parseCABlockReturns
	fake.recordInvocation("ParseCABlock", []interface{}{})
	fake.parseCABlockMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *CAConfig) ParseCABlockCallCount() int {
	fake.parseCABlockMutex.RLock()
	defer fake.parseCABlockMutex.RUnlock()
	return len(fake.parseCABlockArgsForCall)
}

func (fake *CAConfig) ParseCABlockCalls(stub func() (map[string][]byte, error)) {
	fake.parseCABlockMutex.Lock()
	defer fake.parseCABlockMutex.Unlock()
	fake.ParseCABlockStub = stub
}

func (fake *CAConfig) ParseCABlockReturns(result1 map[string][]byte, result2 error) {
	fake.parseCABlockMutex.Lock()
	defer fake.parseCABlockMutex.Unlock()
	fake.ParseCABlockStub = nil
	fake.parseCABlockReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseCABlockReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.parseCABlockMutex.Lock()
	defer fake.parseCABlockMutex.Unlock()
	fake.ParseCABlockStub = nil
	if fake.parseCABlockReturnsOnCall == nil {
		fake.parseCABlockReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.parseCABlockReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseDBBlock() (map[string][]byte, error) {
	fake.parseDBBlockMutex.Lock()
	ret, specificReturn := fake.parseDBBlockReturnsOnCall[len(fake.parseDBBlockArgsForCall)]
	fake.parseDBBlockArgsForCall = append(fake.parseDBBlockArgsForCall, struct {
	}{})
	stub := fake.ParseDBBlockStub
	fakeReturns := fake.parseDBBlockReturns
	fake.recordInvocation("ParseDBBlock", []interface{}{})
	fake.parseDBBlockMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *CAConfig) ParseDBBlockCallCount() int {
	fake.parseDBBlockMutex.RLock()
	defer fake.parseDBBlockMutex.RUnlock()
	return len(fake.parseDBBlockArgsForCall)
}

func (fake *CAConfig) ParseDBBlockCalls(stub func() (map[string][]byte, error)) {
	fake.parseDBBlockMutex.Lock()
	defer fake.parseDBBlockMutex.Unlock()
	fake.ParseDBBlockStub = stub
}

func (fake *CAConfig) ParseDBBlockReturns(result1 map[string][]byte, result2 error) {
	fake.parseDBBlockMutex.Lock()
	defer fake.parseDBBlockMutex.Unlock()
	fake.ParseDBBlockStub = nil
	fake.parseDBBlockReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseDBBlockReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.parseDBBlockMutex.Lock()
	defer fake.parseDBBlockMutex.Unlock()
	fake.ParseDBBlockStub = nil
	if fake.parseDBBlockReturnsOnCall == nil {
		fake.parseDBBlockReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.parseDBBlockReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseIntermediateBlock() (map[string][]byte, error) {
	fake.parseIntermediateBlockMutex.Lock()
	ret, specificReturn := fake.parseIntermediateBlockReturnsOnCall[len(fake.parseIntermediateBlockArgsForCall)]
	fake.parseIntermediateBlockArgsForCall = append(fake.parseIntermediateBlockArgsForCall, struct {
	}{})
	stub := fake.ParseIntermediateBlockStub
	fakeReturns := fake.parseIntermediateBlockReturns
	fake.recordInvocation("ParseIntermediateBlock", []interface{}{})
	fake.parseIntermediateBlockMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *CAConfig) ParseIntermediateBlockCallCount() int {
	fake.parseIntermediateBlockMutex.RLock()
	defer fake.parseIntermediateBlockMutex.RUnlock()
	return len(fake.parseIntermediateBlockArgsForCall)
}

func (fake *CAConfig) ParseIntermediateBlockCalls(stub func() (map[string][]byte, error)) {
	fake.parseIntermediateBlockMutex.Lock()
	defer fake.parseIntermediateBlockMutex.Unlock()
	fake.ParseIntermediateBlockStub = stub
}

func (fake *CAConfig) ParseIntermediateBlockReturns(result1 map[string][]byte, result2 error) {
	fake.parseIntermediateBlockMutex.Lock()
	defer fake.parseIntermediateBlockMutex.Unlock()
	fake.ParseIntermediateBlockStub = nil
	fake.parseIntermediateBlockReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseIntermediateBlockReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.parseIntermediateBlockMutex.Lock()
	defer fake.parseIntermediateBlockMutex.Unlock()
	fake.ParseIntermediateBlockStub = nil
	if fake.parseIntermediateBlockReturnsOnCall == nil {
		fake.parseIntermediateBlockReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.parseIntermediateBlockReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseOperationsBlock() (map[string][]byte, error) {
	fake.parseOperationsBlockMutex.Lock()
	ret, specificReturn := fake.parseOperationsBlockReturnsOnCall[len(fake.parseOperationsBlockArgsForCall)]
	fake.parseOperationsBlockArgsForCall = append(fake.parseOperationsBlockArgsForCall, struct {
	}{})
	stub := fake.ParseOperationsBlockStub
	fakeReturns := fake.parseOperationsBlockReturns
	fake.recordInvocation("ParseOperationsBlock", []interface{}{})
	fake.parseOperationsBlockMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *CAConfig) ParseOperationsBlockCallCount() int {
	fake.parseOperationsBlockMutex.RLock()
	defer fake.parseOperationsBlockMutex.RUnlock()
	return len(fake.parseOperationsBlockArgsForCall)
}

func (fake *CAConfig) ParseOperationsBlockCalls(stub func() (map[string][]byte, error)) {
	fake.parseOperationsBlockMutex.Lock()
	defer fake.parseOperationsBlockMutex.Unlock()
	fake.ParseOperationsBlockStub = stub
}

func (fake *CAConfig) ParseOperationsBlockReturns(result1 map[string][]byte, result2 error) {
	fake.parseOperationsBlockMutex.Lock()
	defer fake.parseOperationsBlockMutex.Unlock()
	fake.ParseOperationsBlockStub = nil
	fake.parseOperationsBlockReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseOperationsBlockReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.parseOperationsBlockMutex.Lock()
	defer fake.parseOperationsBlockMutex.Unlock()
	fake.ParseOperationsBlockStub = nil
	if fake.parseOperationsBlockReturnsOnCall == nil {
		fake.parseOperationsBlockReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.parseOperationsBlockReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseTLSBlock() (map[string][]byte, error) {
	fake.parseTLSBlockMutex.Lock()
	ret, specificReturn := fake.parseTLSBlockReturnsOnCall[len(fake.parseTLSBlockArgsForCall)]
	fake.parseTLSBlockArgsForCall = append(fake.parseTLSBlockArgsForCall, struct {
	}{})
	stub := fake.ParseTLSBlockStub
	fakeReturns := fake.parseTLSBlockReturns
	fake.recordInvocation("ParseTLSBlock", []interface{}{})
	fake.parseTLSBlockMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *CAConfig) ParseTLSBlockCallCount() int {
	fake.parseTLSBlockMutex.RLock()
	defer fake.parseTLSBlockMutex.RUnlock()
	return len(fake.parseTLSBlockArgsForCall)
}

func (fake *CAConfig) ParseTLSBlockCalls(stub func() (map[string][]byte, error)) {
	fake.parseTLSBlockMutex.Lock()
	defer fake.parseTLSBlockMutex.Unlock()
	fake.ParseTLSBlockStub = stub
}

func (fake *CAConfig) ParseTLSBlockReturns(result1 map[string][]byte, result2 error) {
	fake.parseTLSBlockMutex.Lock()
	defer fake.parseTLSBlockMutex.Unlock()
	fake.ParseTLSBlockStub = nil
	fake.parseTLSBlockReturns = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) ParseTLSBlockReturnsOnCall(i int, result1 map[string][]byte, result2 error) {
	fake.parseTLSBlockMutex.Lock()
	defer fake.parseTLSBlockMutex.Unlock()
	fake.ParseTLSBlockStub = nil
	if fake.parseTLSBlockReturnsOnCall == nil {
		fake.parseTLSBlockReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
			result2 error
		})
	}
	fake.parseTLSBlockReturnsOnCall[i] = struct {
		result1 map[string][]byte
		result2 error
	}{result1, result2}
}

func (fake *CAConfig) SetMountPaths(arg1 config.Type) {
	fake.setMountPathsMutex.Lock()
	fake.setMountPathsArgsForCall = append(fake.setMountPathsArgsForCall, struct {
		arg1 config.Type
	}{arg1})
	stub := fake.SetMountPathsStub
	fake.recordInvocation("SetMountPaths", []interface{}{arg1})
	fake.setMountPathsMutex.Unlock()
	if stub != nil {
		fake.SetMountPathsStub(arg1)
	}
}

func (fake *CAConfig) SetMountPathsCallCount() int {
	fake.setMountPathsMutex.RLock()
	defer fake.setMountPathsMutex.RUnlock()
	return len(fake.setMountPathsArgsForCall)
}

func (fake *CAConfig) SetMountPathsCalls(stub func(config.Type)) {
	fake.setMountPathsMutex.Lock()
	defer fake.setMountPathsMutex.Unlock()
	fake.SetMountPathsStub = stub
}

func (fake *CAConfig) SetMountPathsArgsForCall(i int) config.Type {
	fake.setMountPathsMutex.RLock()
	defer fake.setMountPathsMutex.RUnlock()
	argsForCall := fake.setMountPathsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *CAConfig) SetServerConfig(arg1 *v1.ServerConfig) {
	fake.setServerConfigMutex.Lock()
	fake.setServerConfigArgsForCall = append(fake.setServerConfigArgsForCall, struct {
		arg1 *v1.ServerConfig
	}{arg1})
	stub := fake.SetServerConfigStub
	fake.recordInvocation("SetServerConfig", []interface{}{arg1})
	fake.setServerConfigMutex.Unlock()
	if stub != nil {
		fake.SetServerConfigStub(arg1)
	}
}

func (fake *CAConfig) SetServerConfigCallCount() int {
	fake.setServerConfigMutex.RLock()
	defer fake.setServerConfigMutex.RUnlock()
	return len(fake.setServerConfigArgsForCall)
}

func (fake *CAConfig) SetServerConfigCalls(stub func(*v1.ServerConfig)) {
	fake.setServerConfigMutex.Lock()
	defer fake.setServerConfigMutex.Unlock()
	fake.SetServerConfigStub = stub
}

func (fake *CAConfig) SetServerConfigArgsForCall(i int) *v1.ServerConfig {
	fake.setServerConfigMutex.RLock()
	defer fake.setServerConfigMutex.RUnlock()
	argsForCall := fake.setServerConfigArgsForCall[i]
	return argsForCall.arg1
}

func (fake *CAConfig) SetUpdate(arg1 bool) {
	fake.setUpdateMutex.Lock()
	fake.setUpdateArgsForCall = append(fake.setUpdateArgsForCall, struct {
		arg1 bool
	}{arg1})
	stub := fake.SetUpdateStub
	fake.recordInvocation("SetUpdate", []interface{}{arg1})
	fake.setUpdateMutex.Unlock()
	if stub != nil {
		fake.SetUpdateStub(arg1)
	}
}

func (fake *CAConfig) SetUpdateCallCount() int {
	fake.setUpdateMutex.RLock()
	defer fake.setUpdateMutex.RUnlock()
	return len(fake.setUpdateArgsForCall)
}

func (fake *CAConfig) SetUpdateCalls(stub func(bool)) {
	fake.setUpdateMutex.Lock()
	defer fake.setUpdateMutex.Unlock()
	fake.SetUpdateStub = stub
}

func (fake *CAConfig) SetUpdateArgsForCall(i int) bool {
	fake.setUpdateMutex.RLock()
	defer fake.setUpdateMutex.RUnlock()
	argsForCall := fake.setUpdateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *CAConfig) UsingPKCS11() bool {
	fake.usingPKCS11Mutex.Lock()
	ret, specificReturn := fake.usingPKCS11ReturnsOnCall[len(fake.usingPKCS11ArgsForCall)]
	fake.usingPKCS11ArgsForCall = append(fake.usingPKCS11ArgsForCall, struct {
	}{})
	stub := fake.UsingPKCS11Stub
	fakeReturns := fake.usingPKCS11Returns
	fake.recordInvocation("UsingPKCS11", []interface{}{})
	fake.usingPKCS11Mutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *CAConfig) UsingPKCS11CallCount() int {
	fake.usingPKCS11Mutex.RLock()
	defer fake.usingPKCS11Mutex.RUnlock()
	return len(fake.usingPKCS11ArgsForCall)
}

func (fake *CAConfig) UsingPKCS11Calls(stub func() bool) {
	fake.usingPKCS11Mutex.Lock()
	defer fake.usingPKCS11Mutex.Unlock()
	fake.UsingPKCS11Stub = stub
}

func (fake *CAConfig) UsingPKCS11Returns(result1 bool) {
	fake.usingPKCS11Mutex.Lock()
	defer fake.usingPKCS11Mutex.Unlock()
	fake.UsingPKCS11Stub = nil
	fake.usingPKCS11Returns = struct {
		result1 bool
	}{result1}
}

func (fake *CAConfig) UsingPKCS11ReturnsOnCall(i int, result1 bool) {
	fake.usingPKCS11Mutex.Lock()
	defer fake.usingPKCS11Mutex.Unlock()
	fake.UsingPKCS11Stub = nil
	if fake.usingPKCS11ReturnsOnCall == nil {
		fake.usingPKCS11ReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.usingPKCS11ReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *CAConfig) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getHomeDirMutex.RLock()
	defer fake.getHomeDirMutex.RUnlock()
	fake.getServerConfigMutex.RLock()
	defer fake.getServerConfigMutex.RUnlock()
	fake.parseCABlockMutex.RLock()
	defer fake.parseCABlockMutex.RUnlock()
	fake.parseDBBlockMutex.RLock()
	defer fake.parseDBBlockMutex.RUnlock()
	fake.parseIntermediateBlockMutex.RLock()
	defer fake.parseIntermediateBlockMutex.RUnlock()
	fake.parseOperationsBlockMutex.RLock()
	defer fake.parseOperationsBlockMutex.RUnlock()
	fake.parseTLSBlockMutex.RLock()
	defer fake.parseTLSBlockMutex.RUnlock()
	fake.setMountPathsMutex.RLock()
	defer fake.setMountPathsMutex.RUnlock()
	fake.setServerConfigMutex.RLock()
	defer fake.setServerConfigMutex.RUnlock()
	fake.setUpdateMutex.RLock()
	defer fake.setUpdateMutex.RUnlock()
	fake.usingPKCS11Mutex.RLock()
	defer fake.usingPKCS11Mutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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