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

import (
	"sync"

	"code.cloudfoundry.org/cli/cf/configuration/coreconfig"
	"code.cloudfoundry.org/cli/cf/models"
	"github.com/blang/semver/v4"
)

type FakeReadWriter struct {
	APIEndpointStub        func() string
	aPIEndpointMutex       sync.RWMutex
	aPIEndpointArgsForCall []struct {
	}
	aPIEndpointReturns struct {
		result1 string
	}
	aPIEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	APIVersionStub        func() string
	aPIVersionMutex       sync.RWMutex
	aPIVersionArgsForCall []struct {
	}
	aPIVersionReturns struct {
		result1 string
	}
	aPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct {
	}
	accessTokenReturns struct {
		result1 string
	}
	accessTokenReturnsOnCall map[int]struct {
		result1 string
	}
	AsyncTimeoutStub        func() uint
	asyncTimeoutMutex       sync.RWMutex
	asyncTimeoutArgsForCall []struct {
	}
	asyncTimeoutReturns struct {
		result1 uint
	}
	asyncTimeoutReturnsOnCall map[int]struct {
		result1 uint
	}
	AuthenticationEndpointStub        func() string
	authenticationEndpointMutex       sync.RWMutex
	authenticationEndpointArgsForCall []struct {
	}
	authenticationEndpointReturns struct {
		result1 string
	}
	authenticationEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	CLIVersionStub        func() string
	cLIVersionMutex       sync.RWMutex
	cLIVersionArgsForCall []struct {
	}
	cLIVersionReturns struct {
		result1 string
	}
	cLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	ClearSessionStub        func()
	clearSessionMutex       sync.RWMutex
	clearSessionArgsForCall []struct {
	}
	ColorEnabledStub        func() string
	colorEnabledMutex       sync.RWMutex
	colorEnabledArgsForCall []struct {
	}
	colorEnabledReturns struct {
		result1 string
	}
	colorEnabledReturnsOnCall map[int]struct {
		result1 string
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct {
	}
	dopplerEndpointReturns struct {
		result1 string
	}
	dopplerEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	HasAPIEndpointStub        func() bool
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct {
	}
	hasAPIEndpointReturns struct {
		result1 bool
	}
	hasAPIEndpointReturnsOnCall map[int]struct {
		result1 bool
	}
	HasOrganizationStub        func() bool
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct {
	}
	hasOrganizationReturns struct {
		result1 bool
	}
	hasOrganizationReturnsOnCall map[int]struct {
		result1 bool
	}
	HasSpaceStub        func() bool
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct {
	}
	hasSpaceReturns struct {
		result1 bool
	}
	hasSpaceReturnsOnCall map[int]struct {
		result1 bool
	}
	IsLoggedInStub        func() bool
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct {
	}
	isLoggedInReturns struct {
		result1 bool
	}
	isLoggedInReturnsOnCall map[int]struct {
		result1 bool
	}
	IsMinAPIVersionStub        func(semver.Version) bool
	isMinAPIVersionMutex       sync.RWMutex
	isMinAPIVersionArgsForCall []struct {
		arg1 semver.Version
	}
	isMinAPIVersionReturns struct {
		result1 bool
	}
	isMinAPIVersionReturnsOnCall map[int]struct {
		result1 bool
	}
	IsMinCLIVersionStub        func(string) bool
	isMinCLIVersionMutex       sync.RWMutex
	isMinCLIVersionArgsForCall []struct {
		arg1 string
	}
	isMinCLIVersionReturns struct {
		result1 bool
	}
	isMinCLIVersionReturnsOnCall map[int]struct {
		result1 bool
	}
	IsSSLDisabledStub        func() bool
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct {
	}
	isSSLDisabledReturns struct {
		result1 bool
	}
	isSSLDisabledReturnsOnCall map[int]struct {
		result1 bool
	}
	LocaleStub        func() string
	localeMutex       sync.RWMutex
	localeArgsForCall []struct {
	}
	localeReturns struct {
		result1 string
	}
	localeReturnsOnCall map[int]struct {
		result1 string
	}
	LogCacheEndpointStub        func() string
	logCacheEndpointMutex       sync.RWMutex
	logCacheEndpointArgsForCall []struct {
	}
	logCacheEndpointReturns struct {
		result1 string
	}
	logCacheEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	MinCLIVersionStub        func() string
	minCLIVersionMutex       sync.RWMutex
	minCLIVersionArgsForCall []struct {
	}
	minCLIVersionReturns struct {
		result1 string
	}
	minCLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	MinRecommendedCLIVersionStub        func() string
	minRecommendedCLIVersionMutex       sync.RWMutex
	minRecommendedCLIVersionArgsForCall []struct {
	}
	minRecommendedCLIVersionReturns struct {
		result1 string
	}
	minRecommendedCLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	OrganizationFieldsStub        func() models.OrganizationFields
	organizationFieldsMutex       sync.RWMutex
	organizationFieldsArgsForCall []struct {
	}
	organizationFieldsReturns struct {
		result1 models.OrganizationFields
	}
	organizationFieldsReturnsOnCall map[int]struct {
		result1 models.OrganizationFields
	}
	PluginReposStub        func() []models.PluginRepo
	pluginReposMutex       sync.RWMutex
	pluginReposArgsForCall []struct {
	}
	pluginReposReturns struct {
		result1 []models.PluginRepo
	}
	pluginReposReturnsOnCall map[int]struct {
		result1 []models.PluginRepo
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct {
	}
	refreshTokenReturns struct {
		result1 string
	}
	refreshTokenReturnsOnCall map[int]struct {
		result1 string
	}
	RoutingAPIEndpointStub        func() string
	routingAPIEndpointMutex       sync.RWMutex
	routingAPIEndpointArgsForCall []struct {
	}
	routingAPIEndpointReturns struct {
		result1 string
	}
	routingAPIEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	SSHOAuthClientStub        func() string
	sSHOAuthClientMutex       sync.RWMutex
	sSHOAuthClientArgsForCall []struct {
	}
	sSHOAuthClientReturns struct {
		result1 string
	}
	sSHOAuthClientReturnsOnCall map[int]struct {
		result1 string
	}
	SetAPIEndpointStub        func(string)
	setAPIEndpointMutex       sync.RWMutex
	setAPIEndpointArgsForCall []struct {
		arg1 string
	}
	SetAPIVersionStub        func(string)
	setAPIVersionMutex       sync.RWMutex
	setAPIVersionArgsForCall []struct {
		arg1 string
	}
	SetAccessTokenStub        func(string)
	setAccessTokenMutex       sync.RWMutex
	setAccessTokenArgsForCall []struct {
		arg1 string
	}
	SetAsyncTimeoutStub        func(uint)
	setAsyncTimeoutMutex       sync.RWMutex
	setAsyncTimeoutArgsForCall []struct {
		arg1 uint
	}
	SetAuthenticationEndpointStub        func(string)
	setAuthenticationEndpointMutex       sync.RWMutex
	setAuthenticationEndpointArgsForCall []struct {
		arg1 string
	}
	SetCLIVersionStub        func(string)
	setCLIVersionMutex       sync.RWMutex
	setCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetColorEnabledStub        func(string)
	setColorEnabledMutex       sync.RWMutex
	setColorEnabledArgsForCall []struct {
		arg1 string
	}
	SetDopplerEndpointStub        func(string)
	setDopplerEndpointMutex       sync.RWMutex
	setDopplerEndpointArgsForCall []struct {
		arg1 string
	}
	SetLocaleStub        func(string)
	setLocaleMutex       sync.RWMutex
	setLocaleArgsForCall []struct {
		arg1 string
	}
	SetLogCacheEndpointStub        func(string)
	setLogCacheEndpointMutex       sync.RWMutex
	setLogCacheEndpointArgsForCall []struct {
		arg1 string
	}
	SetMinCLIVersionStub        func(string)
	setMinCLIVersionMutex       sync.RWMutex
	setMinCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetMinRecommendedCLIVersionStub        func(string)
	setMinRecommendedCLIVersionMutex       sync.RWMutex
	setMinRecommendedCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetOrganizationFieldsStub        func(models.OrganizationFields)
	setOrganizationFieldsMutex       sync.RWMutex
	setOrganizationFieldsArgsForCall []struct {
		arg1 models.OrganizationFields
	}
	SetPluginRepoStub        func(models.PluginRepo)
	setPluginRepoMutex       sync.RWMutex
	setPluginRepoArgsForCall []struct {
		arg1 models.PluginRepo
	}
	SetRefreshTokenStub        func(string)
	setRefreshTokenMutex       sync.RWMutex
	setRefreshTokenArgsForCall []struct {
		arg1 string
	}
	SetRoutingAPIEndpointStub        func(string)
	setRoutingAPIEndpointMutex       sync.RWMutex
	setRoutingAPIEndpointArgsForCall []struct {
		arg1 string
	}
	SetSSHOAuthClientStub        func(string)
	setSSHOAuthClientMutex       sync.RWMutex
	setSSHOAuthClientArgsForCall []struct {
		arg1 string
	}
	SetSSLDisabledStub        func(bool)
	setSSLDisabledMutex       sync.RWMutex
	setSSLDisabledArgsForCall []struct {
		arg1 bool
	}
	SetSpaceFieldsStub        func(models.SpaceFields)
	setSpaceFieldsMutex       sync.RWMutex
	setSpaceFieldsArgsForCall []struct {
		arg1 models.SpaceFields
	}
	SetTraceStub        func(string)
	setTraceMutex       sync.RWMutex
	setTraceArgsForCall []struct {
		arg1 string
	}
	SetUAAGrantTypeStub        func(string)
	setUAAGrantTypeMutex       sync.RWMutex
	setUAAGrantTypeArgsForCall []struct {
		arg1 string
	}
	SetUAAOAuthClientStub        func(string)
	setUAAOAuthClientMutex       sync.RWMutex
	setUAAOAuthClientArgsForCall []struct {
		arg1 string
	}
	SetUAAOAuthClientSecretStub        func(string)
	setUAAOAuthClientSecretMutex       sync.RWMutex
	setUAAOAuthClientSecretArgsForCall []struct {
		arg1 string
	}
	SetUaaEndpointStub        func(string)
	setUaaEndpointMutex       sync.RWMutex
	setUaaEndpointArgsForCall []struct {
		arg1 string
	}
	SpaceFieldsStub        func() models.SpaceFields
	spaceFieldsMutex       sync.RWMutex
	spaceFieldsArgsForCall []struct {
	}
	spaceFieldsReturns struct {
		result1 models.SpaceFields
	}
	spaceFieldsReturnsOnCall map[int]struct {
		result1 models.SpaceFields
	}
	TraceStub        func() string
	traceMutex       sync.RWMutex
	traceArgsForCall []struct {
	}
	traceReturns struct {
		result1 string
	}
	traceReturnsOnCall map[int]struct {
		result1 string
	}
	UAAGrantTypeStub        func() string
	uAAGrantTypeMutex       sync.RWMutex
	uAAGrantTypeArgsForCall []struct {
	}
	uAAGrantTypeReturns struct {
		result1 string
	}
	uAAGrantTypeReturnsOnCall map[int]struct {
		result1 string
	}
	UAAOAuthClientStub        func() string
	uAAOAuthClientMutex       sync.RWMutex
	uAAOAuthClientArgsForCall []struct {
	}
	uAAOAuthClientReturns struct {
		result1 string
	}
	uAAOAuthClientReturnsOnCall map[int]struct {
		result1 string
	}
	UAAOAuthClientSecretStub        func() string
	uAAOAuthClientSecretMutex       sync.RWMutex
	uAAOAuthClientSecretArgsForCall []struct {
	}
	uAAOAuthClientSecretReturns struct {
		result1 string
	}
	uAAOAuthClientSecretReturnsOnCall map[int]struct {
		result1 string
	}
	UaaEndpointStub        func() string
	uaaEndpointMutex       sync.RWMutex
	uaaEndpointArgsForCall []struct {
	}
	uaaEndpointReturns struct {
		result1 string
	}
	uaaEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	UnSetPluginRepoStub        func(int)
	unSetPluginRepoMutex       sync.RWMutex
	unSetPluginRepoArgsForCall []struct {
		arg1 int
	}
	UserEmailStub        func() string
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct {
	}
	userEmailReturns struct {
		result1 string
	}
	userEmailReturnsOnCall map[int]struct {
		result1 string
	}
	UserGUIDStub        func() string
	userGUIDMutex       sync.RWMutex
	userGUIDArgsForCall []struct {
	}
	userGUIDReturns struct {
		result1 string
	}
	userGUIDReturnsOnCall map[int]struct {
		result1 string
	}
	UsernameStub        func() string
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct {
	}
	usernameReturns struct {
		result1 string
	}
	usernameReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeReadWriter) APIEndpoint() string {
	fake.aPIEndpointMutex.Lock()
	ret, specificReturn := fake.aPIEndpointReturnsOnCall[len(fake.aPIEndpointArgsForCall)]
	fake.aPIEndpointArgsForCall = append(fake.aPIEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("APIEndpoint", []interface{}{})
	fake.aPIEndpointMutex.Unlock()
	if fake.APIEndpointStub != nil {
		return fake.APIEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.aPIEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) APIEndpointCallCount() int {
	fake.aPIEndpointMutex.RLock()
	defer fake.aPIEndpointMutex.RUnlock()
	return len(fake.aPIEndpointArgsForCall)
}

func (fake *FakeReadWriter) APIEndpointCalls(stub func() string) {
	fake.aPIEndpointMutex.Lock()
	defer fake.aPIEndpointMutex.Unlock()
	fake.APIEndpointStub = stub
}

func (fake *FakeReadWriter) APIEndpointReturns(result1 string) {
	fake.aPIEndpointMutex.Lock()
	defer fake.aPIEndpointMutex.Unlock()
	fake.APIEndpointStub = nil
	fake.aPIEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) APIEndpointReturnsOnCall(i int, result1 string) {
	fake.aPIEndpointMutex.Lock()
	defer fake.aPIEndpointMutex.Unlock()
	fake.APIEndpointStub = nil
	if fake.aPIEndpointReturnsOnCall == nil {
		fake.aPIEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) APIVersion() string {
	fake.aPIVersionMutex.Lock()
	ret, specificReturn := fake.aPIVersionReturnsOnCall[len(fake.aPIVersionArgsForCall)]
	fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("APIVersion", []interface{}{})
	fake.aPIVersionMutex.Unlock()
	if fake.APIVersionStub != nil {
		return fake.APIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.aPIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) APIVersionCallCount() int {
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	return len(fake.aPIVersionArgsForCall)
}

func (fake *FakeReadWriter) APIVersionCalls(stub func() string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = stub
}

func (fake *FakeReadWriter) APIVersionReturns(result1 string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = nil
	fake.aPIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) APIVersionReturnsOnCall(i int, result1 string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = nil
	if fake.aPIVersionReturnsOnCall == nil {
		fake.aPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) AccessToken() string {
	fake.accessTokenMutex.Lock()
	ret, specificReturn := fake.accessTokenReturnsOnCall[len(fake.accessTokenArgsForCall)]
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("AccessToken", []interface{}{})
	fake.accessTokenMutex.Unlock()
	if fake.AccessTokenStub != nil {
		return fake.AccessTokenStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.accessTokenReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) AccessTokenCallCount() int {
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	return len(fake.accessTokenArgsForCall)
}

func (fake *FakeReadWriter) AccessTokenCalls(stub func() string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = stub
}

func (fake *FakeReadWriter) AccessTokenReturns(result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	fake.accessTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) AccessTokenReturnsOnCall(i int, result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	if fake.accessTokenReturnsOnCall == nil {
		fake.accessTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.accessTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) AsyncTimeout() uint {
	fake.asyncTimeoutMutex.Lock()
	ret, specificReturn := fake.asyncTimeoutReturnsOnCall[len(fake.asyncTimeoutArgsForCall)]
	fake.asyncTimeoutArgsForCall = append(fake.asyncTimeoutArgsForCall, struct {
	}{})
	fake.recordInvocation("AsyncTimeout", []interface{}{})
	fake.asyncTimeoutMutex.Unlock()
	if fake.AsyncTimeoutStub != nil {
		return fake.AsyncTimeoutStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.asyncTimeoutReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) AsyncTimeoutCallCount() int {
	fake.asyncTimeoutMutex.RLock()
	defer fake.asyncTimeoutMutex.RUnlock()
	return len(fake.asyncTimeoutArgsForCall)
}

func (fake *FakeReadWriter) AsyncTimeoutCalls(stub func() uint) {
	fake.asyncTimeoutMutex.Lock()
	defer fake.asyncTimeoutMutex.Unlock()
	fake.AsyncTimeoutStub = stub
}

func (fake *FakeReadWriter) AsyncTimeoutReturns(result1 uint) {
	fake.asyncTimeoutMutex.Lock()
	defer fake.asyncTimeoutMutex.Unlock()
	fake.AsyncTimeoutStub = nil
	fake.asyncTimeoutReturns = struct {
		result1 uint
	}{result1}
}

func (fake *FakeReadWriter) AsyncTimeoutReturnsOnCall(i int, result1 uint) {
	fake.asyncTimeoutMutex.Lock()
	defer fake.asyncTimeoutMutex.Unlock()
	fake.AsyncTimeoutStub = nil
	if fake.asyncTimeoutReturnsOnCall == nil {
		fake.asyncTimeoutReturnsOnCall = make(map[int]struct {
			result1 uint
		})
	}
	fake.asyncTimeoutReturnsOnCall[i] = struct {
		result1 uint
	}{result1}
}

func (fake *FakeReadWriter) AuthenticationEndpoint() string {
	fake.authenticationEndpointMutex.Lock()
	ret, specificReturn := fake.authenticationEndpointReturnsOnCall[len(fake.authenticationEndpointArgsForCall)]
	fake.authenticationEndpointArgsForCall = append(fake.authenticationEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("AuthenticationEndpoint", []interface{}{})
	fake.authenticationEndpointMutex.Unlock()
	if fake.AuthenticationEndpointStub != nil {
		return fake.AuthenticationEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.authenticationEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) AuthenticationEndpointCallCount() int {
	fake.authenticationEndpointMutex.RLock()
	defer fake.authenticationEndpointMutex.RUnlock()
	return len(fake.authenticationEndpointArgsForCall)
}

func (fake *FakeReadWriter) AuthenticationEndpointCalls(stub func() string) {
	fake.authenticationEndpointMutex.Lock()
	defer fake.authenticationEndpointMutex.Unlock()
	fake.AuthenticationEndpointStub = stub
}

func (fake *FakeReadWriter) AuthenticationEndpointReturns(result1 string) {
	fake.authenticationEndpointMutex.Lock()
	defer fake.authenticationEndpointMutex.Unlock()
	fake.AuthenticationEndpointStub = nil
	fake.authenticationEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) AuthenticationEndpointReturnsOnCall(i int, result1 string) {
	fake.authenticationEndpointMutex.Lock()
	defer fake.authenticationEndpointMutex.Unlock()
	fake.AuthenticationEndpointStub = nil
	if fake.authenticationEndpointReturnsOnCall == nil {
		fake.authenticationEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.authenticationEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) CLIVersion() string {
	fake.cLIVersionMutex.Lock()
	ret, specificReturn := fake.cLIVersionReturnsOnCall[len(fake.cLIVersionArgsForCall)]
	fake.cLIVersionArgsForCall = append(fake.cLIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("CLIVersion", []interface{}{})
	fake.cLIVersionMutex.Unlock()
	if fake.CLIVersionStub != nil {
		return fake.CLIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.cLIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) CLIVersionCallCount() int {
	fake.cLIVersionMutex.RLock()
	defer fake.cLIVersionMutex.RUnlock()
	return len(fake.cLIVersionArgsForCall)
}

func (fake *FakeReadWriter) CLIVersionCalls(stub func() string) {
	fake.cLIVersionMutex.Lock()
	defer fake.cLIVersionMutex.Unlock()
	fake.CLIVersionStub = stub
}

func (fake *FakeReadWriter) CLIVersionReturns(result1 string) {
	fake.cLIVersionMutex.Lock()
	defer fake.cLIVersionMutex.Unlock()
	fake.CLIVersionStub = nil
	fake.cLIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) CLIVersionReturnsOnCall(i int, result1 string) {
	fake.cLIVersionMutex.Lock()
	defer fake.cLIVersionMutex.Unlock()
	fake.CLIVersionStub = nil
	if fake.cLIVersionReturnsOnCall == nil {
		fake.cLIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cLIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) ClearSession() {
	fake.clearSessionMutex.Lock()
	fake.clearSessionArgsForCall = append(fake.clearSessionArgsForCall, struct {
	}{})
	fake.recordInvocation("ClearSession", []interface{}{})
	fake.clearSessionMutex.Unlock()
	if fake.ClearSessionStub != nil {
		fake.ClearSessionStub()
	}
}

func (fake *FakeReadWriter) ClearSessionCallCount() int {
	fake.clearSessionMutex.RLock()
	defer fake.clearSessionMutex.RUnlock()
	return len(fake.clearSessionArgsForCall)
}

func (fake *FakeReadWriter) ClearSessionCalls(stub func()) {
	fake.clearSessionMutex.Lock()
	defer fake.clearSessionMutex.Unlock()
	fake.ClearSessionStub = stub
}

func (fake *FakeReadWriter) ColorEnabled() string {
	fake.colorEnabledMutex.Lock()
	ret, specificReturn := fake.colorEnabledReturnsOnCall[len(fake.colorEnabledArgsForCall)]
	fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct {
	}{})
	fake.recordInvocation("ColorEnabled", []interface{}{})
	fake.colorEnabledMutex.Unlock()
	if fake.ColorEnabledStub != nil {
		return fake.ColorEnabledStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.colorEnabledReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) ColorEnabledCallCount() int {
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	return len(fake.colorEnabledArgsForCall)
}

func (fake *FakeReadWriter) ColorEnabledCalls(stub func() string) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = stub
}

func (fake *FakeReadWriter) ColorEnabledReturns(result1 string) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = nil
	fake.colorEnabledReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) ColorEnabledReturnsOnCall(i int, result1 string) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = nil
	if fake.colorEnabledReturnsOnCall == nil {
		fake.colorEnabledReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.colorEnabledReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) DopplerEndpoint() string {
	fake.dopplerEndpointMutex.Lock()
	ret, specificReturn := fake.dopplerEndpointReturnsOnCall[len(fake.dopplerEndpointArgsForCall)]
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("DopplerEndpoint", []interface{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.dopplerEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) DopplerEndpointCallCount() int {
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	return len(fake.dopplerEndpointArgsForCall)
}

func (fake *FakeReadWriter) DopplerEndpointCalls(stub func() string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = stub
}

func (fake *FakeReadWriter) DopplerEndpointReturns(result1 string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = nil
	fake.dopplerEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) DopplerEndpointReturnsOnCall(i int, result1 string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = nil
	if fake.dopplerEndpointReturnsOnCall == nil {
		fake.dopplerEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.dopplerEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) HasAPIEndpoint() bool {
	fake.hasAPIEndpointMutex.Lock()
	ret, specificReturn := fake.hasAPIEndpointReturnsOnCall[len(fake.hasAPIEndpointArgsForCall)]
	fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("HasAPIEndpoint", []interface{}{})
	fake.hasAPIEndpointMutex.Unlock()
	if fake.HasAPIEndpointStub != nil {
		return fake.HasAPIEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasAPIEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) HasAPIEndpointCallCount() int {
	fake.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	return len(fake.hasAPIEndpointArgsForCall)
}

func (fake *FakeReadWriter) HasAPIEndpointCalls(stub func() bool) {
	fake.hasAPIEndpointMutex.Lock()
	defer fake.hasAPIEndpointMutex.Unlock()
	fake.HasAPIEndpointStub = stub
}

func (fake *FakeReadWriter) HasAPIEndpointReturns(result1 bool) {
	fake.hasAPIEndpointMutex.Lock()
	defer fake.hasAPIEndpointMutex.Unlock()
	fake.HasAPIEndpointStub = nil
	fake.hasAPIEndpointReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) HasAPIEndpointReturnsOnCall(i int, result1 bool) {
	fake.hasAPIEndpointMutex.Lock()
	defer fake.hasAPIEndpointMutex.Unlock()
	fake.HasAPIEndpointStub = nil
	if fake.hasAPIEndpointReturnsOnCall == nil {
		fake.hasAPIEndpointReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasAPIEndpointReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) HasOrganization() bool {
	fake.hasOrganizationMutex.Lock()
	ret, specificReturn := fake.hasOrganizationReturnsOnCall[len(fake.hasOrganizationArgsForCall)]
	fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct {
	}{})
	fake.recordInvocation("HasOrganization", []interface{}{})
	fake.hasOrganizationMutex.Unlock()
	if fake.HasOrganizationStub != nil {
		return fake.HasOrganizationStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasOrganizationReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) HasOrganizationCallCount() int {
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	return len(fake.hasOrganizationArgsForCall)
}

func (fake *FakeReadWriter) HasOrganizationCalls(stub func() bool) {
	fake.hasOrganizationMutex.Lock()
	defer fake.hasOrganizationMutex.Unlock()
	fake.HasOrganizationStub = stub
}

func (fake *FakeReadWriter) HasOrganizationReturns(result1 bool) {
	fake.hasOrganizationMutex.Lock()
	defer fake.hasOrganizationMutex.Unlock()
	fake.HasOrganizationStub = nil
	fake.hasOrganizationReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) HasOrganizationReturnsOnCall(i int, result1 bool) {
	fake.hasOrganizationMutex.Lock()
	defer fake.hasOrganizationMutex.Unlock()
	fake.HasOrganizationStub = nil
	if fake.hasOrganizationReturnsOnCall == nil {
		fake.hasOrganizationReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasOrganizationReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) HasSpace() bool {
	fake.hasSpaceMutex.Lock()
	ret, specificReturn := fake.hasSpaceReturnsOnCall[len(fake.hasSpaceArgsForCall)]
	fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct {
	}{})
	fake.recordInvocation("HasSpace", []interface{}{})
	fake.hasSpaceMutex.Unlock()
	if fake.HasSpaceStub != nil {
		return fake.HasSpaceStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasSpaceReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) HasSpaceCallCount() int {
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	return len(fake.hasSpaceArgsForCall)
}

func (fake *FakeReadWriter) HasSpaceCalls(stub func() bool) {
	fake.hasSpaceMutex.Lock()
	defer fake.hasSpaceMutex.Unlock()
	fake.HasSpaceStub = stub
}

func (fake *FakeReadWriter) HasSpaceReturns(result1 bool) {
	fake.hasSpaceMutex.Lock()
	defer fake.hasSpaceMutex.Unlock()
	fake.HasSpaceStub = nil
	fake.hasSpaceReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) HasSpaceReturnsOnCall(i int, result1 bool) {
	fake.hasSpaceMutex.Lock()
	defer fake.hasSpaceMutex.Unlock()
	fake.HasSpaceStub = nil
	if fake.hasSpaceReturnsOnCall == nil {
		fake.hasSpaceReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasSpaceReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsLoggedIn() bool {
	fake.isLoggedInMutex.Lock()
	ret, specificReturn := fake.isLoggedInReturnsOnCall[len(fake.isLoggedInArgsForCall)]
	fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct {
	}{})
	fake.recordInvocation("IsLoggedIn", []interface{}{})
	fake.isLoggedInMutex.Unlock()
	if fake.IsLoggedInStub != nil {
		return fake.IsLoggedInStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isLoggedInReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) IsLoggedInCallCount() int {
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	return len(fake.isLoggedInArgsForCall)
}

func (fake *FakeReadWriter) IsLoggedInCalls(stub func() bool) {
	fake.isLoggedInMutex.Lock()
	defer fake.isLoggedInMutex.Unlock()
	fake.IsLoggedInStub = stub
}

func (fake *FakeReadWriter) IsLoggedInReturns(result1 bool) {
	fake.isLoggedInMutex.Lock()
	defer fake.isLoggedInMutex.Unlock()
	fake.IsLoggedInStub = nil
	fake.isLoggedInReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsLoggedInReturnsOnCall(i int, result1 bool) {
	fake.isLoggedInMutex.Lock()
	defer fake.isLoggedInMutex.Unlock()
	fake.IsLoggedInStub = nil
	if fake.isLoggedInReturnsOnCall == nil {
		fake.isLoggedInReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isLoggedInReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsMinAPIVersion(arg1 semver.Version) bool {
	fake.isMinAPIVersionMutex.Lock()
	ret, specificReturn := fake.isMinAPIVersionReturnsOnCall[len(fake.isMinAPIVersionArgsForCall)]
	fake.isMinAPIVersionArgsForCall = append(fake.isMinAPIVersionArgsForCall, struct {
		arg1 semver.Version
	}{arg1})
	fake.recordInvocation("IsMinAPIVersion", []interface{}{arg1})
	fake.isMinAPIVersionMutex.Unlock()
	if fake.IsMinAPIVersionStub != nil {
		return fake.IsMinAPIVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isMinAPIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) IsMinAPIVersionCallCount() int {
	fake.isMinAPIVersionMutex.RLock()
	defer fake.isMinAPIVersionMutex.RUnlock()
	return len(fake.isMinAPIVersionArgsForCall)
}

func (fake *FakeReadWriter) IsMinAPIVersionCalls(stub func(semver.Version) bool) {
	fake.isMinAPIVersionMutex.Lock()
	defer fake.isMinAPIVersionMutex.Unlock()
	fake.IsMinAPIVersionStub = stub
}

func (fake *FakeReadWriter) IsMinAPIVersionArgsForCall(i int) semver.Version {
	fake.isMinAPIVersionMutex.RLock()
	defer fake.isMinAPIVersionMutex.RUnlock()
	argsForCall := fake.isMinAPIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) IsMinAPIVersionReturns(result1 bool) {
	fake.isMinAPIVersionMutex.Lock()
	defer fake.isMinAPIVersionMutex.Unlock()
	fake.IsMinAPIVersionStub = nil
	fake.isMinAPIVersionReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsMinAPIVersionReturnsOnCall(i int, result1 bool) {
	fake.isMinAPIVersionMutex.Lock()
	defer fake.isMinAPIVersionMutex.Unlock()
	fake.IsMinAPIVersionStub = nil
	if fake.isMinAPIVersionReturnsOnCall == nil {
		fake.isMinAPIVersionReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isMinAPIVersionReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsMinCLIVersion(arg1 string) bool {
	fake.isMinCLIVersionMutex.Lock()
	ret, specificReturn := fake.isMinCLIVersionReturnsOnCall[len(fake.isMinCLIVersionArgsForCall)]
	fake.isMinCLIVersionArgsForCall = append(fake.isMinCLIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("IsMinCLIVersion", []interface{}{arg1})
	fake.isMinCLIVersionMutex.Unlock()
	if fake.IsMinCLIVersionStub != nil {
		return fake.IsMinCLIVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isMinCLIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) IsMinCLIVersionCallCount() int {
	fake.isMinCLIVersionMutex.RLock()
	defer fake.isMinCLIVersionMutex.RUnlock()
	return len(fake.isMinCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) IsMinCLIVersionCalls(stub func(string) bool) {
	fake.isMinCLIVersionMutex.Lock()
	defer fake.isMinCLIVersionMutex.Unlock()
	fake.IsMinCLIVersionStub = stub
}

func (fake *FakeReadWriter) IsMinCLIVersionArgsForCall(i int) string {
	fake.isMinCLIVersionMutex.RLock()
	defer fake.isMinCLIVersionMutex.RUnlock()
	argsForCall := fake.isMinCLIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) IsMinCLIVersionReturns(result1 bool) {
	fake.isMinCLIVersionMutex.Lock()
	defer fake.isMinCLIVersionMutex.Unlock()
	fake.IsMinCLIVersionStub = nil
	fake.isMinCLIVersionReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsMinCLIVersionReturnsOnCall(i int, result1 bool) {
	fake.isMinCLIVersionMutex.Lock()
	defer fake.isMinCLIVersionMutex.Unlock()
	fake.IsMinCLIVersionStub = nil
	if fake.isMinCLIVersionReturnsOnCall == nil {
		fake.isMinCLIVersionReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isMinCLIVersionReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsSSLDisabled() bool {
	fake.isSSLDisabledMutex.Lock()
	ret, specificReturn := fake.isSSLDisabledReturnsOnCall[len(fake.isSSLDisabledArgsForCall)]
	fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct {
	}{})
	fake.recordInvocation("IsSSLDisabled", []interface{}{})
	fake.isSSLDisabledMutex.Unlock()
	if fake.IsSSLDisabledStub != nil {
		return fake.IsSSLDisabledStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isSSLDisabledReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) IsSSLDisabledCallCount() int {
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	return len(fake.isSSLDisabledArgsForCall)
}

func (fake *FakeReadWriter) IsSSLDisabledCalls(stub func() bool) {
	fake.isSSLDisabledMutex.Lock()
	defer fake.isSSLDisabledMutex.Unlock()
	fake.IsSSLDisabledStub = stub
}

func (fake *FakeReadWriter) IsSSLDisabledReturns(result1 bool) {
	fake.isSSLDisabledMutex.Lock()
	defer fake.isSSLDisabledMutex.Unlock()
	fake.IsSSLDisabledStub = nil
	fake.isSSLDisabledReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) IsSSLDisabledReturnsOnCall(i int, result1 bool) {
	fake.isSSLDisabledMutex.Lock()
	defer fake.isSSLDisabledMutex.Unlock()
	fake.IsSSLDisabledStub = nil
	if fake.isSSLDisabledReturnsOnCall == nil {
		fake.isSSLDisabledReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isSSLDisabledReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeReadWriter) Locale() string {
	fake.localeMutex.Lock()
	ret, specificReturn := fake.localeReturnsOnCall[len(fake.localeArgsForCall)]
	fake.localeArgsForCall = append(fake.localeArgsForCall, struct {
	}{})
	fake.recordInvocation("Locale", []interface{}{})
	fake.localeMutex.Unlock()
	if fake.LocaleStub != nil {
		return fake.LocaleStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.localeReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) LocaleCallCount() int {
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	return len(fake.localeArgsForCall)
}

func (fake *FakeReadWriter) LocaleCalls(stub func() string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = stub
}

func (fake *FakeReadWriter) LocaleReturns(result1 string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = nil
	fake.localeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) LocaleReturnsOnCall(i int, result1 string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = nil
	if fake.localeReturnsOnCall == nil {
		fake.localeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.localeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) LogCacheEndpoint() string {
	fake.logCacheEndpointMutex.Lock()
	ret, specificReturn := fake.logCacheEndpointReturnsOnCall[len(fake.logCacheEndpointArgsForCall)]
	fake.logCacheEndpointArgsForCall = append(fake.logCacheEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("LogCacheEndpoint", []interface{}{})
	fake.logCacheEndpointMutex.Unlock()
	if fake.LogCacheEndpointStub != nil {
		return fake.LogCacheEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.logCacheEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) LogCacheEndpointCallCount() int {
	fake.logCacheEndpointMutex.RLock()
	defer fake.logCacheEndpointMutex.RUnlock()
	return len(fake.logCacheEndpointArgsForCall)
}

func (fake *FakeReadWriter) LogCacheEndpointCalls(stub func() string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = stub
}

func (fake *FakeReadWriter) LogCacheEndpointReturns(result1 string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = nil
	fake.logCacheEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) LogCacheEndpointReturnsOnCall(i int, result1 string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = nil
	if fake.logCacheEndpointReturnsOnCall == nil {
		fake.logCacheEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.logCacheEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) MinCLIVersion() string {
	fake.minCLIVersionMutex.Lock()
	ret, specificReturn := fake.minCLIVersionReturnsOnCall[len(fake.minCLIVersionArgsForCall)]
	fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("MinCLIVersion", []interface{}{})
	fake.minCLIVersionMutex.Unlock()
	if fake.MinCLIVersionStub != nil {
		return fake.MinCLIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.minCLIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) MinCLIVersionCallCount() int {
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	return len(fake.minCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) MinCLIVersionCalls(stub func() string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = stub
}

func (fake *FakeReadWriter) MinCLIVersionReturns(result1 string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = nil
	fake.minCLIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) MinCLIVersionReturnsOnCall(i int, result1 string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = nil
	if fake.minCLIVersionReturnsOnCall == nil {
		fake.minCLIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.minCLIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) MinRecommendedCLIVersion() string {
	fake.minRecommendedCLIVersionMutex.Lock()
	ret, specificReturn := fake.minRecommendedCLIVersionReturnsOnCall[len(fake.minRecommendedCLIVersionArgsForCall)]
	fake.minRecommendedCLIVersionArgsForCall = append(fake.minRecommendedCLIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("MinRecommendedCLIVersion", []interface{}{})
	fake.minRecommendedCLIVersionMutex.Unlock()
	if fake.MinRecommendedCLIVersionStub != nil {
		return fake.MinRecommendedCLIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.minRecommendedCLIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) MinRecommendedCLIVersionCallCount() int {
	fake.minRecommendedCLIVersionMutex.RLock()
	defer fake.minRecommendedCLIVersionMutex.RUnlock()
	return len(fake.minRecommendedCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) MinRecommendedCLIVersionCalls(stub func() string) {
	fake.minRecommendedCLIVersionMutex.Lock()
	defer fake.minRecommendedCLIVersionMutex.Unlock()
	fake.MinRecommendedCLIVersionStub = stub
}

func (fake *FakeReadWriter) MinRecommendedCLIVersionReturns(result1 string) {
	fake.minRecommendedCLIVersionMutex.Lock()
	defer fake.minRecommendedCLIVersionMutex.Unlock()
	fake.MinRecommendedCLIVersionStub = nil
	fake.minRecommendedCLIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) MinRecommendedCLIVersionReturnsOnCall(i int, result1 string) {
	fake.minRecommendedCLIVersionMutex.Lock()
	defer fake.minRecommendedCLIVersionMutex.Unlock()
	fake.MinRecommendedCLIVersionStub = nil
	if fake.minRecommendedCLIVersionReturnsOnCall == nil {
		fake.minRecommendedCLIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.minRecommendedCLIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) OrganizationFields() models.OrganizationFields {
	fake.organizationFieldsMutex.Lock()
	ret, specificReturn := fake.organizationFieldsReturnsOnCall[len(fake.organizationFieldsArgsForCall)]
	fake.organizationFieldsArgsForCall = append(fake.organizationFieldsArgsForCall, struct {
	}{})
	fake.recordInvocation("OrganizationFields", []interface{}{})
	fake.organizationFieldsMutex.Unlock()
	if fake.OrganizationFieldsStub != nil {
		return fake.OrganizationFieldsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.organizationFieldsReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) OrganizationFieldsCallCount() int {
	fake.organizationFieldsMutex.RLock()
	defer fake.organizationFieldsMutex.RUnlock()
	return len(fake.organizationFieldsArgsForCall)
}

func (fake *FakeReadWriter) OrganizationFieldsCalls(stub func() models.OrganizationFields) {
	fake.organizationFieldsMutex.Lock()
	defer fake.organizationFieldsMutex.Unlock()
	fake.OrganizationFieldsStub = stub
}

func (fake *FakeReadWriter) OrganizationFieldsReturns(result1 models.OrganizationFields) {
	fake.organizationFieldsMutex.Lock()
	defer fake.organizationFieldsMutex.Unlock()
	fake.OrganizationFieldsStub = nil
	fake.organizationFieldsReturns = struct {
		result1 models.OrganizationFields
	}{result1}
}

func (fake *FakeReadWriter) OrganizationFieldsReturnsOnCall(i int, result1 models.OrganizationFields) {
	fake.organizationFieldsMutex.Lock()
	defer fake.organizationFieldsMutex.Unlock()
	fake.OrganizationFieldsStub = nil
	if fake.organizationFieldsReturnsOnCall == nil {
		fake.organizationFieldsReturnsOnCall = make(map[int]struct {
			result1 models.OrganizationFields
		})
	}
	fake.organizationFieldsReturnsOnCall[i] = struct {
		result1 models.OrganizationFields
	}{result1}
}

func (fake *FakeReadWriter) PluginRepos() []models.PluginRepo {
	fake.pluginReposMutex.Lock()
	ret, specificReturn := fake.pluginReposReturnsOnCall[len(fake.pluginReposArgsForCall)]
	fake.pluginReposArgsForCall = append(fake.pluginReposArgsForCall, struct {
	}{})
	fake.recordInvocation("PluginRepos", []interface{}{})
	fake.pluginReposMutex.Unlock()
	if fake.PluginReposStub != nil {
		return fake.PluginReposStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pluginReposReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) PluginReposCallCount() int {
	fake.pluginReposMutex.RLock()
	defer fake.pluginReposMutex.RUnlock()
	return len(fake.pluginReposArgsForCall)
}

func (fake *FakeReadWriter) PluginReposCalls(stub func() []models.PluginRepo) {
	fake.pluginReposMutex.Lock()
	defer fake.pluginReposMutex.Unlock()
	fake.PluginReposStub = stub
}

func (fake *FakeReadWriter) PluginReposReturns(result1 []models.PluginRepo) {
	fake.pluginReposMutex.Lock()
	defer fake.pluginReposMutex.Unlock()
	fake.PluginReposStub = nil
	fake.pluginReposReturns = struct {
		result1 []models.PluginRepo
	}{result1}
}

func (fake *FakeReadWriter) PluginReposReturnsOnCall(i int, result1 []models.PluginRepo) {
	fake.pluginReposMutex.Lock()
	defer fake.pluginReposMutex.Unlock()
	fake.PluginReposStub = nil
	if fake.pluginReposReturnsOnCall == nil {
		fake.pluginReposReturnsOnCall = make(map[int]struct {
			result1 []models.PluginRepo
		})
	}
	fake.pluginReposReturnsOnCall[i] = struct {
		result1 []models.PluginRepo
	}{result1}
}

func (fake *FakeReadWriter) RefreshToken() string {
	fake.refreshTokenMutex.Lock()
	ret, specificReturn := fake.refreshTokenReturnsOnCall[len(fake.refreshTokenArgsForCall)]
	fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("RefreshToken", []interface{}{})
	fake.refreshTokenMutex.Unlock()
	if fake.RefreshTokenStub != nil {
		return fake.RefreshTokenStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.refreshTokenReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) RefreshTokenCallCount() int {
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	return len(fake.refreshTokenArgsForCall)
}

func (fake *FakeReadWriter) RefreshTokenCalls(stub func() string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = stub
}

func (fake *FakeReadWriter) RefreshTokenReturns(result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	fake.refreshTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) RefreshTokenReturnsOnCall(i int, result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	if fake.refreshTokenReturnsOnCall == nil {
		fake.refreshTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.refreshTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) RoutingAPIEndpoint() string {
	fake.routingAPIEndpointMutex.Lock()
	ret, specificReturn := fake.routingAPIEndpointReturnsOnCall[len(fake.routingAPIEndpointArgsForCall)]
	fake.routingAPIEndpointArgsForCall = append(fake.routingAPIEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("RoutingAPIEndpoint", []interface{}{})
	fake.routingAPIEndpointMutex.Unlock()
	if fake.RoutingAPIEndpointStub != nil {
		return fake.RoutingAPIEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.routingAPIEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) RoutingAPIEndpointCallCount() int {
	fake.routingAPIEndpointMutex.RLock()
	defer fake.routingAPIEndpointMutex.RUnlock()
	return len(fake.routingAPIEndpointArgsForCall)
}

func (fake *FakeReadWriter) RoutingAPIEndpointCalls(stub func() string) {
	fake.routingAPIEndpointMutex.Lock()
	defer fake.routingAPIEndpointMutex.Unlock()
	fake.RoutingAPIEndpointStub = stub
}

func (fake *FakeReadWriter) RoutingAPIEndpointReturns(result1 string) {
	fake.routingAPIEndpointMutex.Lock()
	defer fake.routingAPIEndpointMutex.Unlock()
	fake.RoutingAPIEndpointStub = nil
	fake.routingAPIEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) RoutingAPIEndpointReturnsOnCall(i int, result1 string) {
	fake.routingAPIEndpointMutex.Lock()
	defer fake.routingAPIEndpointMutex.Unlock()
	fake.RoutingAPIEndpointStub = nil
	if fake.routingAPIEndpointReturnsOnCall == nil {
		fake.routingAPIEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.routingAPIEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) SSHOAuthClient() string {
	fake.sSHOAuthClientMutex.Lock()
	ret, specificReturn := fake.sSHOAuthClientReturnsOnCall[len(fake.sSHOAuthClientArgsForCall)]
	fake.sSHOAuthClientArgsForCall = append(fake.sSHOAuthClientArgsForCall, struct {
	}{})
	fake.recordInvocation("SSHOAuthClient", []interface{}{})
	fake.sSHOAuthClientMutex.Unlock()
	if fake.SSHOAuthClientStub != nil {
		return fake.SSHOAuthClientStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.sSHOAuthClientReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) SSHOAuthClientCallCount() int {
	fake.sSHOAuthClientMutex.RLock()
	defer fake.sSHOAuthClientMutex.RUnlock()
	return len(fake.sSHOAuthClientArgsForCall)
}

func (fake *FakeReadWriter) SSHOAuthClientCalls(stub func() string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = stub
}

func (fake *FakeReadWriter) SSHOAuthClientReturns(result1 string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = nil
	fake.sSHOAuthClientReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) SSHOAuthClientReturnsOnCall(i int, result1 string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = nil
	if fake.sSHOAuthClientReturnsOnCall == nil {
		fake.sSHOAuthClientReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.sSHOAuthClientReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) SetAPIEndpoint(arg1 string) {
	fake.setAPIEndpointMutex.Lock()
	fake.setAPIEndpointArgsForCall = append(fake.setAPIEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetAPIEndpoint", []interface{}{arg1})
	fake.setAPIEndpointMutex.Unlock()
	if fake.SetAPIEndpointStub != nil {
		fake.SetAPIEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetAPIEndpointCallCount() int {
	fake.setAPIEndpointMutex.RLock()
	defer fake.setAPIEndpointMutex.RUnlock()
	return len(fake.setAPIEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetAPIEndpointCalls(stub func(string)) {
	fake.setAPIEndpointMutex.Lock()
	defer fake.setAPIEndpointMutex.Unlock()
	fake.SetAPIEndpointStub = stub
}

func (fake *FakeReadWriter) SetAPIEndpointArgsForCall(i int) string {
	fake.setAPIEndpointMutex.RLock()
	defer fake.setAPIEndpointMutex.RUnlock()
	argsForCall := fake.setAPIEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetAPIVersion(arg1 string) {
	fake.setAPIVersionMutex.Lock()
	fake.setAPIVersionArgsForCall = append(fake.setAPIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetAPIVersion", []interface{}{arg1})
	fake.setAPIVersionMutex.Unlock()
	if fake.SetAPIVersionStub != nil {
		fake.SetAPIVersionStub(arg1)
	}
}

func (fake *FakeReadWriter) SetAPIVersionCallCount() int {
	fake.setAPIVersionMutex.RLock()
	defer fake.setAPIVersionMutex.RUnlock()
	return len(fake.setAPIVersionArgsForCall)
}

func (fake *FakeReadWriter) SetAPIVersionCalls(stub func(string)) {
	fake.setAPIVersionMutex.Lock()
	defer fake.setAPIVersionMutex.Unlock()
	fake.SetAPIVersionStub = stub
}

func (fake *FakeReadWriter) SetAPIVersionArgsForCall(i int) string {
	fake.setAPIVersionMutex.RLock()
	defer fake.setAPIVersionMutex.RUnlock()
	argsForCall := fake.setAPIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetAccessToken(arg1 string) {
	fake.setAccessTokenMutex.Lock()
	fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetAccessToken", []interface{}{arg1})
	fake.setAccessTokenMutex.Unlock()
	if fake.SetAccessTokenStub != nil {
		fake.SetAccessTokenStub(arg1)
	}
}

func (fake *FakeReadWriter) SetAccessTokenCallCount() int {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	return len(fake.setAccessTokenArgsForCall)
}

func (fake *FakeReadWriter) SetAccessTokenCalls(stub func(string)) {
	fake.setAccessTokenMutex.Lock()
	defer fake.setAccessTokenMutex.Unlock()
	fake.SetAccessTokenStub = stub
}

func (fake *FakeReadWriter) SetAccessTokenArgsForCall(i int) string {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	argsForCall := fake.setAccessTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetAsyncTimeout(arg1 uint) {
	fake.setAsyncTimeoutMutex.Lock()
	fake.setAsyncTimeoutArgsForCall = append(fake.setAsyncTimeoutArgsForCall, struct {
		arg1 uint
	}{arg1})
	fake.recordInvocation("SetAsyncTimeout", []interface{}{arg1})
	fake.setAsyncTimeoutMutex.Unlock()
	if fake.SetAsyncTimeoutStub != nil {
		fake.SetAsyncTimeoutStub(arg1)
	}
}

func (fake *FakeReadWriter) SetAsyncTimeoutCallCount() int {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	return len(fake.setAsyncTimeoutArgsForCall)
}

func (fake *FakeReadWriter) SetAsyncTimeoutCalls(stub func(uint)) {
	fake.setAsyncTimeoutMutex.Lock()
	defer fake.setAsyncTimeoutMutex.Unlock()
	fake.SetAsyncTimeoutStub = stub
}

func (fake *FakeReadWriter) SetAsyncTimeoutArgsForCall(i int) uint {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	argsForCall := fake.setAsyncTimeoutArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetAuthenticationEndpoint(arg1 string) {
	fake.setAuthenticationEndpointMutex.Lock()
	fake.setAuthenticationEndpointArgsForCall = append(fake.setAuthenticationEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetAuthenticationEndpoint", []interface{}{arg1})
	fake.setAuthenticationEndpointMutex.Unlock()
	if fake.SetAuthenticationEndpointStub != nil {
		fake.SetAuthenticationEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetAuthenticationEndpointCallCount() int {
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	return len(fake.setAuthenticationEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetAuthenticationEndpointCalls(stub func(string)) {
	fake.setAuthenticationEndpointMutex.Lock()
	defer fake.setAuthenticationEndpointMutex.Unlock()
	fake.SetAuthenticationEndpointStub = stub
}

func (fake *FakeReadWriter) SetAuthenticationEndpointArgsForCall(i int) string {
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	argsForCall := fake.setAuthenticationEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetCLIVersion(arg1 string) {
	fake.setCLIVersionMutex.Lock()
	fake.setCLIVersionArgsForCall = append(fake.setCLIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetCLIVersion", []interface{}{arg1})
	fake.setCLIVersionMutex.Unlock()
	if fake.SetCLIVersionStub != nil {
		fake.SetCLIVersionStub(arg1)
	}
}

func (fake *FakeReadWriter) SetCLIVersionCallCount() int {
	fake.setCLIVersionMutex.RLock()
	defer fake.setCLIVersionMutex.RUnlock()
	return len(fake.setCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) SetCLIVersionCalls(stub func(string)) {
	fake.setCLIVersionMutex.Lock()
	defer fake.setCLIVersionMutex.Unlock()
	fake.SetCLIVersionStub = stub
}

func (fake *FakeReadWriter) SetCLIVersionArgsForCall(i int) string {
	fake.setCLIVersionMutex.RLock()
	defer fake.setCLIVersionMutex.RUnlock()
	argsForCall := fake.setCLIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetColorEnabled(arg1 string) {
	fake.setColorEnabledMutex.Lock()
	fake.setColorEnabledArgsForCall = append(fake.setColorEnabledArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetColorEnabled", []interface{}{arg1})
	fake.setColorEnabledMutex.Unlock()
	if fake.SetColorEnabledStub != nil {
		fake.SetColorEnabledStub(arg1)
	}
}

func (fake *FakeReadWriter) SetColorEnabledCallCount() int {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	return len(fake.setColorEnabledArgsForCall)
}

func (fake *FakeReadWriter) SetColorEnabledCalls(stub func(string)) {
	fake.setColorEnabledMutex.Lock()
	defer fake.setColorEnabledMutex.Unlock()
	fake.SetColorEnabledStub = stub
}

func (fake *FakeReadWriter) SetColorEnabledArgsForCall(i int) string {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	argsForCall := fake.setColorEnabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetDopplerEndpoint(arg1 string) {
	fake.setDopplerEndpointMutex.Lock()
	fake.setDopplerEndpointArgsForCall = append(fake.setDopplerEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetDopplerEndpoint", []interface{}{arg1})
	fake.setDopplerEndpointMutex.Unlock()
	if fake.SetDopplerEndpointStub != nil {
		fake.SetDopplerEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetDopplerEndpointCallCount() int {
	fake.setDopplerEndpointMutex.RLock()
	defer fake.setDopplerEndpointMutex.RUnlock()
	return len(fake.setDopplerEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetDopplerEndpointCalls(stub func(string)) {
	fake.setDopplerEndpointMutex.Lock()
	defer fake.setDopplerEndpointMutex.Unlock()
	fake.SetDopplerEndpointStub = stub
}

func (fake *FakeReadWriter) SetDopplerEndpointArgsForCall(i int) string {
	fake.setDopplerEndpointMutex.RLock()
	defer fake.setDopplerEndpointMutex.RUnlock()
	argsForCall := fake.setDopplerEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetLocale(arg1 string) {
	fake.setLocaleMutex.Lock()
	fake.setLocaleArgsForCall = append(fake.setLocaleArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetLocale", []interface{}{arg1})
	fake.setLocaleMutex.Unlock()
	if fake.SetLocaleStub != nil {
		fake.SetLocaleStub(arg1)
	}
}

func (fake *FakeReadWriter) SetLocaleCallCount() int {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	return len(fake.setLocaleArgsForCall)
}

func (fake *FakeReadWriter) SetLocaleCalls(stub func(string)) {
	fake.setLocaleMutex.Lock()
	defer fake.setLocaleMutex.Unlock()
	fake.SetLocaleStub = stub
}

func (fake *FakeReadWriter) SetLocaleArgsForCall(i int) string {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	argsForCall := fake.setLocaleArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetLogCacheEndpoint(arg1 string) {
	fake.setLogCacheEndpointMutex.Lock()
	fake.setLogCacheEndpointArgsForCall = append(fake.setLogCacheEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetLogCacheEndpoint", []interface{}{arg1})
	fake.setLogCacheEndpointMutex.Unlock()
	if fake.SetLogCacheEndpointStub != nil {
		fake.SetLogCacheEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetLogCacheEndpointCallCount() int {
	fake.setLogCacheEndpointMutex.RLock()
	defer fake.setLogCacheEndpointMutex.RUnlock()
	return len(fake.setLogCacheEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetLogCacheEndpointCalls(stub func(string)) {
	fake.setLogCacheEndpointMutex.Lock()
	defer fake.setLogCacheEndpointMutex.Unlock()
	fake.SetLogCacheEndpointStub = stub
}

func (fake *FakeReadWriter) SetLogCacheEndpointArgsForCall(i int) string {
	fake.setLogCacheEndpointMutex.RLock()
	defer fake.setLogCacheEndpointMutex.RUnlock()
	argsForCall := fake.setLogCacheEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetMinCLIVersion(arg1 string) {
	fake.setMinCLIVersionMutex.Lock()
	fake.setMinCLIVersionArgsForCall = append(fake.setMinCLIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetMinCLIVersion", []interface{}{arg1})
	fake.setMinCLIVersionMutex.Unlock()
	if fake.SetMinCLIVersionStub != nil {
		fake.SetMinCLIVersionStub(arg1)
	}
}

func (fake *FakeReadWriter) SetMinCLIVersionCallCount() int {
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	return len(fake.setMinCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) SetMinCLIVersionCalls(stub func(string)) {
	fake.setMinCLIVersionMutex.Lock()
	defer fake.setMinCLIVersionMutex.Unlock()
	fake.SetMinCLIVersionStub = stub
}

func (fake *FakeReadWriter) SetMinCLIVersionArgsForCall(i int) string {
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	argsForCall := fake.setMinCLIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetMinRecommendedCLIVersion(arg1 string) {
	fake.setMinRecommendedCLIVersionMutex.Lock()
	fake.setMinRecommendedCLIVersionArgsForCall = append(fake.setMinRecommendedCLIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetMinRecommendedCLIVersion", []interface{}{arg1})
	fake.setMinRecommendedCLIVersionMutex.Unlock()
	if fake.SetMinRecommendedCLIVersionStub != nil {
		fake.SetMinRecommendedCLIVersionStub(arg1)
	}
}

func (fake *FakeReadWriter) SetMinRecommendedCLIVersionCallCount() int {
	fake.setMinRecommendedCLIVersionMutex.RLock()
	defer fake.setMinRecommendedCLIVersionMutex.RUnlock()
	return len(fake.setMinRecommendedCLIVersionArgsForCall)
}

func (fake *FakeReadWriter) SetMinRecommendedCLIVersionCalls(stub func(string)) {
	fake.setMinRecommendedCLIVersionMutex.Lock()
	defer fake.setMinRecommendedCLIVersionMutex.Unlock()
	fake.SetMinRecommendedCLIVersionStub = stub
}

func (fake *FakeReadWriter) SetMinRecommendedCLIVersionArgsForCall(i int) string {
	fake.setMinRecommendedCLIVersionMutex.RLock()
	defer fake.setMinRecommendedCLIVersionMutex.RUnlock()
	argsForCall := fake.setMinRecommendedCLIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetOrganizationFields(arg1 models.OrganizationFields) {
	fake.setOrganizationFieldsMutex.Lock()
	fake.setOrganizationFieldsArgsForCall = append(fake.setOrganizationFieldsArgsForCall, struct {
		arg1 models.OrganizationFields
	}{arg1})
	fake.recordInvocation("SetOrganizationFields", []interface{}{arg1})
	fake.setOrganizationFieldsMutex.Unlock()
	if fake.SetOrganizationFieldsStub != nil {
		fake.SetOrganizationFieldsStub(arg1)
	}
}

func (fake *FakeReadWriter) SetOrganizationFieldsCallCount() int {
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	return len(fake.setOrganizationFieldsArgsForCall)
}

func (fake *FakeReadWriter) SetOrganizationFieldsCalls(stub func(models.OrganizationFields)) {
	fake.setOrganizationFieldsMutex.Lock()
	defer fake.setOrganizationFieldsMutex.Unlock()
	fake.SetOrganizationFieldsStub = stub
}

func (fake *FakeReadWriter) SetOrganizationFieldsArgsForCall(i int) models.OrganizationFields {
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	argsForCall := fake.setOrganizationFieldsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetPluginRepo(arg1 models.PluginRepo) {
	fake.setPluginRepoMutex.Lock()
	fake.setPluginRepoArgsForCall = append(fake.setPluginRepoArgsForCall, struct {
		arg1 models.PluginRepo
	}{arg1})
	fake.recordInvocation("SetPluginRepo", []interface{}{arg1})
	fake.setPluginRepoMutex.Unlock()
	if fake.SetPluginRepoStub != nil {
		fake.SetPluginRepoStub(arg1)
	}
}

func (fake *FakeReadWriter) SetPluginRepoCallCount() int {
	fake.setPluginRepoMutex.RLock()
	defer fake.setPluginRepoMutex.RUnlock()
	return len(fake.setPluginRepoArgsForCall)
}

func (fake *FakeReadWriter) SetPluginRepoCalls(stub func(models.PluginRepo)) {
	fake.setPluginRepoMutex.Lock()
	defer fake.setPluginRepoMutex.Unlock()
	fake.SetPluginRepoStub = stub
}

func (fake *FakeReadWriter) SetPluginRepoArgsForCall(i int) models.PluginRepo {
	fake.setPluginRepoMutex.RLock()
	defer fake.setPluginRepoMutex.RUnlock()
	argsForCall := fake.setPluginRepoArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetRefreshToken(arg1 string) {
	fake.setRefreshTokenMutex.Lock()
	fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetRefreshToken", []interface{}{arg1})
	fake.setRefreshTokenMutex.Unlock()
	if fake.SetRefreshTokenStub != nil {
		fake.SetRefreshTokenStub(arg1)
	}
}

func (fake *FakeReadWriter) SetRefreshTokenCallCount() int {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	return len(fake.setRefreshTokenArgsForCall)
}

func (fake *FakeReadWriter) SetRefreshTokenCalls(stub func(string)) {
	fake.setRefreshTokenMutex.Lock()
	defer fake.setRefreshTokenMutex.Unlock()
	fake.SetRefreshTokenStub = stub
}

func (fake *FakeReadWriter) SetRefreshTokenArgsForCall(i int) string {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	argsForCall := fake.setRefreshTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetRoutingAPIEndpoint(arg1 string) {
	fake.setRoutingAPIEndpointMutex.Lock()
	fake.setRoutingAPIEndpointArgsForCall = append(fake.setRoutingAPIEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetRoutingAPIEndpoint", []interface{}{arg1})
	fake.setRoutingAPIEndpointMutex.Unlock()
	if fake.SetRoutingAPIEndpointStub != nil {
		fake.SetRoutingAPIEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetRoutingAPIEndpointCallCount() int {
	fake.setRoutingAPIEndpointMutex.RLock()
	defer fake.setRoutingAPIEndpointMutex.RUnlock()
	return len(fake.setRoutingAPIEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetRoutingAPIEndpointCalls(stub func(string)) {
	fake.setRoutingAPIEndpointMutex.Lock()
	defer fake.setRoutingAPIEndpointMutex.Unlock()
	fake.SetRoutingAPIEndpointStub = stub
}

func (fake *FakeReadWriter) SetRoutingAPIEndpointArgsForCall(i int) string {
	fake.setRoutingAPIEndpointMutex.RLock()
	defer fake.setRoutingAPIEndpointMutex.RUnlock()
	argsForCall := fake.setRoutingAPIEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetSSHOAuthClient(arg1 string) {
	fake.setSSHOAuthClientMutex.Lock()
	fake.setSSHOAuthClientArgsForCall = append(fake.setSSHOAuthClientArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetSSHOAuthClient", []interface{}{arg1})
	fake.setSSHOAuthClientMutex.Unlock()
	if fake.SetSSHOAuthClientStub != nil {
		fake.SetSSHOAuthClientStub(arg1)
	}
}

func (fake *FakeReadWriter) SetSSHOAuthClientCallCount() int {
	fake.setSSHOAuthClientMutex.RLock()
	defer fake.setSSHOAuthClientMutex.RUnlock()
	return len(fake.setSSHOAuthClientArgsForCall)
}

func (fake *FakeReadWriter) SetSSHOAuthClientCalls(stub func(string)) {
	fake.setSSHOAuthClientMutex.Lock()
	defer fake.setSSHOAuthClientMutex.Unlock()
	fake.SetSSHOAuthClientStub = stub
}

func (fake *FakeReadWriter) SetSSHOAuthClientArgsForCall(i int) string {
	fake.setSSHOAuthClientMutex.RLock()
	defer fake.setSSHOAuthClientMutex.RUnlock()
	argsForCall := fake.setSSHOAuthClientArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetSSLDisabled(arg1 bool) {
	fake.setSSLDisabledMutex.Lock()
	fake.setSSLDisabledArgsForCall = append(fake.setSSLDisabledArgsForCall, struct {
		arg1 bool
	}{arg1})
	fake.recordInvocation("SetSSLDisabled", []interface{}{arg1})
	fake.setSSLDisabledMutex.Unlock()
	if fake.SetSSLDisabledStub != nil {
		fake.SetSSLDisabledStub(arg1)
	}
}

func (fake *FakeReadWriter) SetSSLDisabledCallCount() int {
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	return len(fake.setSSLDisabledArgsForCall)
}

func (fake *FakeReadWriter) SetSSLDisabledCalls(stub func(bool)) {
	fake.setSSLDisabledMutex.Lock()
	defer fake.setSSLDisabledMutex.Unlock()
	fake.SetSSLDisabledStub = stub
}

func (fake *FakeReadWriter) SetSSLDisabledArgsForCall(i int) bool {
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	argsForCall := fake.setSSLDisabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetSpaceFields(arg1 models.SpaceFields) {
	fake.setSpaceFieldsMutex.Lock()
	fake.setSpaceFieldsArgsForCall = append(fake.setSpaceFieldsArgsForCall, struct {
		arg1 models.SpaceFields
	}{arg1})
	fake.recordInvocation("SetSpaceFields", []interface{}{arg1})
	fake.setSpaceFieldsMutex.Unlock()
	if fake.SetSpaceFieldsStub != nil {
		fake.SetSpaceFieldsStub(arg1)
	}
}

func (fake *FakeReadWriter) SetSpaceFieldsCallCount() int {
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	return len(fake.setSpaceFieldsArgsForCall)
}

func (fake *FakeReadWriter) SetSpaceFieldsCalls(stub func(models.SpaceFields)) {
	fake.setSpaceFieldsMutex.Lock()
	defer fake.setSpaceFieldsMutex.Unlock()
	fake.SetSpaceFieldsStub = stub
}

func (fake *FakeReadWriter) SetSpaceFieldsArgsForCall(i int) models.SpaceFields {
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	argsForCall := fake.setSpaceFieldsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetTrace(arg1 string) {
	fake.setTraceMutex.Lock()
	fake.setTraceArgsForCall = append(fake.setTraceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetTrace", []interface{}{arg1})
	fake.setTraceMutex.Unlock()
	if fake.SetTraceStub != nil {
		fake.SetTraceStub(arg1)
	}
}

func (fake *FakeReadWriter) SetTraceCallCount() int {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	return len(fake.setTraceArgsForCall)
}

func (fake *FakeReadWriter) SetTraceCalls(stub func(string)) {
	fake.setTraceMutex.Lock()
	defer fake.setTraceMutex.Unlock()
	fake.SetTraceStub = stub
}

func (fake *FakeReadWriter) SetTraceArgsForCall(i int) string {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	argsForCall := fake.setTraceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetUAAGrantType(arg1 string) {
	fake.setUAAGrantTypeMutex.Lock()
	fake.setUAAGrantTypeArgsForCall = append(fake.setUAAGrantTypeArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetUAAGrantType", []interface{}{arg1})
	fake.setUAAGrantTypeMutex.Unlock()
	if fake.SetUAAGrantTypeStub != nil {
		fake.SetUAAGrantTypeStub(arg1)
	}
}

func (fake *FakeReadWriter) SetUAAGrantTypeCallCount() int {
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	return len(fake.setUAAGrantTypeArgsForCall)
}

func (fake *FakeReadWriter) SetUAAGrantTypeCalls(stub func(string)) {
	fake.setUAAGrantTypeMutex.Lock()
	defer fake.setUAAGrantTypeMutex.Unlock()
	fake.SetUAAGrantTypeStub = stub
}

func (fake *FakeReadWriter) SetUAAGrantTypeArgsForCall(i int) string {
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	argsForCall := fake.setUAAGrantTypeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetUAAOAuthClient(arg1 string) {
	fake.setUAAOAuthClientMutex.Lock()
	fake.setUAAOAuthClientArgsForCall = append(fake.setUAAOAuthClientArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetUAAOAuthClient", []interface{}{arg1})
	fake.setUAAOAuthClientMutex.Unlock()
	if fake.SetUAAOAuthClientStub != nil {
		fake.SetUAAOAuthClientStub(arg1)
	}
}

func (fake *FakeReadWriter) SetUAAOAuthClientCallCount() int {
	fake.setUAAOAuthClientMutex.RLock()
	defer fake.setUAAOAuthClientMutex.RUnlock()
	return len(fake.setUAAOAuthClientArgsForCall)
}

func (fake *FakeReadWriter) SetUAAOAuthClientCalls(stub func(string)) {
	fake.setUAAOAuthClientMutex.Lock()
	defer fake.setUAAOAuthClientMutex.Unlock()
	fake.SetUAAOAuthClientStub = stub
}

func (fake *FakeReadWriter) SetUAAOAuthClientArgsForCall(i int) string {
	fake.setUAAOAuthClientMutex.RLock()
	defer fake.setUAAOAuthClientMutex.RUnlock()
	argsForCall := fake.setUAAOAuthClientArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetUAAOAuthClientSecret(arg1 string) {
	fake.setUAAOAuthClientSecretMutex.Lock()
	fake.setUAAOAuthClientSecretArgsForCall = append(fake.setUAAOAuthClientSecretArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetUAAOAuthClientSecret", []interface{}{arg1})
	fake.setUAAOAuthClientSecretMutex.Unlock()
	if fake.SetUAAOAuthClientSecretStub != nil {
		fake.SetUAAOAuthClientSecretStub(arg1)
	}
}

func (fake *FakeReadWriter) SetUAAOAuthClientSecretCallCount() int {
	fake.setUAAOAuthClientSecretMutex.RLock()
	defer fake.setUAAOAuthClientSecretMutex.RUnlock()
	return len(fake.setUAAOAuthClientSecretArgsForCall)
}

func (fake *FakeReadWriter) SetUAAOAuthClientSecretCalls(stub func(string)) {
	fake.setUAAOAuthClientSecretMutex.Lock()
	defer fake.setUAAOAuthClientSecretMutex.Unlock()
	fake.SetUAAOAuthClientSecretStub = stub
}

func (fake *FakeReadWriter) SetUAAOAuthClientSecretArgsForCall(i int) string {
	fake.setUAAOAuthClientSecretMutex.RLock()
	defer fake.setUAAOAuthClientSecretMutex.RUnlock()
	argsForCall := fake.setUAAOAuthClientSecretArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SetUaaEndpoint(arg1 string) {
	fake.setUaaEndpointMutex.Lock()
	fake.setUaaEndpointArgsForCall = append(fake.setUaaEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetUaaEndpoint", []interface{}{arg1})
	fake.setUaaEndpointMutex.Unlock()
	if fake.SetUaaEndpointStub != nil {
		fake.SetUaaEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetUaaEndpointCallCount() int {
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	return len(fake.setUaaEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetUaaEndpointCalls(stub func(string)) {
	fake.setUaaEndpointMutex.Lock()
	defer fake.setUaaEndpointMutex.Unlock()
	fake.SetUaaEndpointStub = stub
}

func (fake *FakeReadWriter) SetUaaEndpointArgsForCall(i int) string {
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	argsForCall := fake.setUaaEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) SpaceFields() models.SpaceFields {
	fake.spaceFieldsMutex.Lock()
	ret, specificReturn := fake.spaceFieldsReturnsOnCall[len(fake.spaceFieldsArgsForCall)]
	fake.spaceFieldsArgsForCall = append(fake.spaceFieldsArgsForCall, struct {
	}{})
	fake.recordInvocation("SpaceFields", []interface{}{})
	fake.spaceFieldsMutex.Unlock()
	if fake.SpaceFieldsStub != nil {
		return fake.SpaceFieldsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.spaceFieldsReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) SpaceFieldsCallCount() int {
	fake.spaceFieldsMutex.RLock()
	defer fake.spaceFieldsMutex.RUnlock()
	return len(fake.spaceFieldsArgsForCall)
}

func (fake *FakeReadWriter) SpaceFieldsCalls(stub func() models.SpaceFields) {
	fake.spaceFieldsMutex.Lock()
	defer fake.spaceFieldsMutex.Unlock()
	fake.SpaceFieldsStub = stub
}

func (fake *FakeReadWriter) SpaceFieldsReturns(result1 models.SpaceFields) {
	fake.spaceFieldsMutex.Lock()
	defer fake.spaceFieldsMutex.Unlock()
	fake.SpaceFieldsStub = nil
	fake.spaceFieldsReturns = struct {
		result1 models.SpaceFields
	}{result1}
}

func (fake *FakeReadWriter) SpaceFieldsReturnsOnCall(i int, result1 models.SpaceFields) {
	fake.spaceFieldsMutex.Lock()
	defer fake.spaceFieldsMutex.Unlock()
	fake.SpaceFieldsStub = nil
	if fake.spaceFieldsReturnsOnCall == nil {
		fake.spaceFieldsReturnsOnCall = make(map[int]struct {
			result1 models.SpaceFields
		})
	}
	fake.spaceFieldsReturnsOnCall[i] = struct {
		result1 models.SpaceFields
	}{result1}
}

func (fake *FakeReadWriter) Trace() string {
	fake.traceMutex.Lock()
	ret, specificReturn := fake.traceReturnsOnCall[len(fake.traceArgsForCall)]
	fake.traceArgsForCall = append(fake.traceArgsForCall, struct {
	}{})
	fake.recordInvocation("Trace", []interface{}{})
	fake.traceMutex.Unlock()
	if fake.TraceStub != nil {
		return fake.TraceStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.traceReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) TraceCallCount() int {
	fake.traceMutex.RLock()
	defer fake.traceMutex.RUnlock()
	return len(fake.traceArgsForCall)
}

func (fake *FakeReadWriter) TraceCalls(stub func() string) {
	fake.traceMutex.Lock()
	defer fake.traceMutex.Unlock()
	fake.TraceStub = stub
}

func (fake *FakeReadWriter) TraceReturns(result1 string) {
	fake.traceMutex.Lock()
	defer fake.traceMutex.Unlock()
	fake.TraceStub = nil
	fake.traceReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) TraceReturnsOnCall(i int, result1 string) {
	fake.traceMutex.Lock()
	defer fake.traceMutex.Unlock()
	fake.TraceStub = nil
	if fake.traceReturnsOnCall == nil {
		fake.traceReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.traceReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAGrantType() string {
	fake.uAAGrantTypeMutex.Lock()
	ret, specificReturn := fake.uAAGrantTypeReturnsOnCall[len(fake.uAAGrantTypeArgsForCall)]
	fake.uAAGrantTypeArgsForCall = append(fake.uAAGrantTypeArgsForCall, struct {
	}{})
	fake.recordInvocation("UAAGrantType", []interface{}{})
	fake.uAAGrantTypeMutex.Unlock()
	if fake.UAAGrantTypeStub != nil {
		return fake.UAAGrantTypeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.uAAGrantTypeReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UAAGrantTypeCallCount() int {
	fake.uAAGrantTypeMutex.RLock()
	defer fake.uAAGrantTypeMutex.RUnlock()
	return len(fake.uAAGrantTypeArgsForCall)
}

func (fake *FakeReadWriter) UAAGrantTypeCalls(stub func() string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = stub
}

func (fake *FakeReadWriter) UAAGrantTypeReturns(result1 string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = nil
	fake.uAAGrantTypeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAGrantTypeReturnsOnCall(i int, result1 string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = nil
	if fake.uAAGrantTypeReturnsOnCall == nil {
		fake.uAAGrantTypeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAGrantTypeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAOAuthClient() string {
	fake.uAAOAuthClientMutex.Lock()
	ret, specificReturn := fake.uAAOAuthClientReturnsOnCall[len(fake.uAAOAuthClientArgsForCall)]
	fake.uAAOAuthClientArgsForCall = append(fake.uAAOAuthClientArgsForCall, struct {
	}{})
	fake.recordInvocation("UAAOAuthClient", []interface{}{})
	fake.uAAOAuthClientMutex.Unlock()
	if fake.UAAOAuthClientStub != nil {
		return fake.UAAOAuthClientStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.uAAOAuthClientReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UAAOAuthClientCallCount() int {
	fake.uAAOAuthClientMutex.RLock()
	defer fake.uAAOAuthClientMutex.RUnlock()
	return len(fake.uAAOAuthClientArgsForCall)
}

func (fake *FakeReadWriter) UAAOAuthClientCalls(stub func() string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = stub
}

func (fake *FakeReadWriter) UAAOAuthClientReturns(result1 string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = nil
	fake.uAAOAuthClientReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAOAuthClientReturnsOnCall(i int, result1 string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = nil
	if fake.uAAOAuthClientReturnsOnCall == nil {
		fake.uAAOAuthClientReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAOAuthClientReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAOAuthClientSecret() string {
	fake.uAAOAuthClientSecretMutex.Lock()
	ret, specificReturn := fake.uAAOAuthClientSecretReturnsOnCall[len(fake.uAAOAuthClientSecretArgsForCall)]
	fake.uAAOAuthClientSecretArgsForCall = append(fake.uAAOAuthClientSecretArgsForCall, struct {
	}{})
	fake.recordInvocation("UAAOAuthClientSecret", []interface{}{})
	fake.uAAOAuthClientSecretMutex.Unlock()
	if fake.UAAOAuthClientSecretStub != nil {
		return fake.UAAOAuthClientSecretStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.uAAOAuthClientSecretReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UAAOAuthClientSecretCallCount() int {
	fake.uAAOAuthClientSecretMutex.RLock()
	defer fake.uAAOAuthClientSecretMutex.RUnlock()
	return len(fake.uAAOAuthClientSecretArgsForCall)
}

func (fake *FakeReadWriter) UAAOAuthClientSecretCalls(stub func() string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = stub
}

func (fake *FakeReadWriter) UAAOAuthClientSecretReturns(result1 string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = nil
	fake.uAAOAuthClientSecretReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UAAOAuthClientSecretReturnsOnCall(i int, result1 string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = nil
	if fake.uAAOAuthClientSecretReturnsOnCall == nil {
		fake.uAAOAuthClientSecretReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAOAuthClientSecretReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UaaEndpoint() string {
	fake.uaaEndpointMutex.Lock()
	ret, specificReturn := fake.uaaEndpointReturnsOnCall[len(fake.uaaEndpointArgsForCall)]
	fake.uaaEndpointArgsForCall = append(fake.uaaEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("UaaEndpoint", []interface{}{})
	fake.uaaEndpointMutex.Unlock()
	if fake.UaaEndpointStub != nil {
		return fake.UaaEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.uaaEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UaaEndpointCallCount() int {
	fake.uaaEndpointMutex.RLock()
	defer fake.uaaEndpointMutex.RUnlock()
	return len(fake.uaaEndpointArgsForCall)
}

func (fake *FakeReadWriter) UaaEndpointCalls(stub func() string) {
	fake.uaaEndpointMutex.Lock()
	defer fake.uaaEndpointMutex.Unlock()
	fake.UaaEndpointStub = stub
}

func (fake *FakeReadWriter) UaaEndpointReturns(result1 string) {
	fake.uaaEndpointMutex.Lock()
	defer fake.uaaEndpointMutex.Unlock()
	fake.UaaEndpointStub = nil
	fake.uaaEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UaaEndpointReturnsOnCall(i int, result1 string) {
	fake.uaaEndpointMutex.Lock()
	defer fake.uaaEndpointMutex.Unlock()
	fake.UaaEndpointStub = nil
	if fake.uaaEndpointReturnsOnCall == nil {
		fake.uaaEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uaaEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UnSetPluginRepo(arg1 int) {
	fake.unSetPluginRepoMutex.Lock()
	fake.unSetPluginRepoArgsForCall = append(fake.unSetPluginRepoArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("UnSetPluginRepo", []interface{}{arg1})
	fake.unSetPluginRepoMutex.Unlock()
	if fake.UnSetPluginRepoStub != nil {
		fake.UnSetPluginRepoStub(arg1)
	}
}

func (fake *FakeReadWriter) UnSetPluginRepoCallCount() int {
	fake.unSetPluginRepoMutex.RLock()
	defer fake.unSetPluginRepoMutex.RUnlock()
	return len(fake.unSetPluginRepoArgsForCall)
}

func (fake *FakeReadWriter) UnSetPluginRepoCalls(stub func(int)) {
	fake.unSetPluginRepoMutex.Lock()
	defer fake.unSetPluginRepoMutex.Unlock()
	fake.UnSetPluginRepoStub = stub
}

func (fake *FakeReadWriter) UnSetPluginRepoArgsForCall(i int) int {
	fake.unSetPluginRepoMutex.RLock()
	defer fake.unSetPluginRepoMutex.RUnlock()
	argsForCall := fake.unSetPluginRepoArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeReadWriter) UserEmail() string {
	fake.userEmailMutex.Lock()
	ret, specificReturn := fake.userEmailReturnsOnCall[len(fake.userEmailArgsForCall)]
	fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct {
	}{})
	fake.recordInvocation("UserEmail", []interface{}{})
	fake.userEmailMutex.Unlock()
	if fake.UserEmailStub != nil {
		return fake.UserEmailStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.userEmailReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UserEmailCallCount() int {
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	return len(fake.userEmailArgsForCall)
}

func (fake *FakeReadWriter) UserEmailCalls(stub func() string) {
	fake.userEmailMutex.Lock()
	defer fake.userEmailMutex.Unlock()
	fake.UserEmailStub = stub
}

func (fake *FakeReadWriter) UserEmailReturns(result1 string) {
	fake.userEmailMutex.Lock()
	defer fake.userEmailMutex.Unlock()
	fake.UserEmailStub = nil
	fake.userEmailReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UserEmailReturnsOnCall(i int, result1 string) {
	fake.userEmailMutex.Lock()
	defer fake.userEmailMutex.Unlock()
	fake.UserEmailStub = nil
	if fake.userEmailReturnsOnCall == nil {
		fake.userEmailReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.userEmailReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UserGUID() string {
	fake.userGUIDMutex.Lock()
	ret, specificReturn := fake.userGUIDReturnsOnCall[len(fake.userGUIDArgsForCall)]
	fake.userGUIDArgsForCall = append(fake.userGUIDArgsForCall, struct {
	}{})
	fake.recordInvocation("UserGUID", []interface{}{})
	fake.userGUIDMutex.Unlock()
	if fake.UserGUIDStub != nil {
		return fake.UserGUIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.userGUIDReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UserGUIDCallCount() int {
	fake.userGUIDMutex.RLock()
	defer fake.userGUIDMutex.RUnlock()
	return len(fake.userGUIDArgsForCall)
}

func (fake *FakeReadWriter) UserGUIDCalls(stub func() string) {
	fake.userGUIDMutex.Lock()
	defer fake.userGUIDMutex.Unlock()
	fake.UserGUIDStub = stub
}

func (fake *FakeReadWriter) UserGUIDReturns(result1 string) {
	fake.userGUIDMutex.Lock()
	defer fake.userGUIDMutex.Unlock()
	fake.UserGUIDStub = nil
	fake.userGUIDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UserGUIDReturnsOnCall(i int, result1 string) {
	fake.userGUIDMutex.Lock()
	defer fake.userGUIDMutex.Unlock()
	fake.UserGUIDStub = nil
	if fake.userGUIDReturnsOnCall == nil {
		fake.userGUIDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.userGUIDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) Username() string {
	fake.usernameMutex.Lock()
	ret, specificReturn := fake.usernameReturnsOnCall[len(fake.usernameArgsForCall)]
	fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct {
	}{})
	fake.recordInvocation("Username", []interface{}{})
	fake.usernameMutex.Unlock()
	if fake.UsernameStub != nil {
		return fake.UsernameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.usernameReturns
	return fakeReturns.result1
}

func (fake *FakeReadWriter) UsernameCallCount() int {
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	return len(fake.usernameArgsForCall)
}

func (fake *FakeReadWriter) UsernameCalls(stub func() string) {
	fake.usernameMutex.Lock()
	defer fake.usernameMutex.Unlock()
	fake.UsernameStub = stub
}

func (fake *FakeReadWriter) UsernameReturns(result1 string) {
	fake.usernameMutex.Lock()
	defer fake.usernameMutex.Unlock()
	fake.UsernameStub = nil
	fake.usernameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) UsernameReturnsOnCall(i int, result1 string) {
	fake.usernameMutex.Lock()
	defer fake.usernameMutex.Unlock()
	fake.UsernameStub = nil
	if fake.usernameReturnsOnCall == nil {
		fake.usernameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.usernameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.aPIEndpointMutex.RLock()
	defer fake.aPIEndpointMutex.RUnlock()
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	fake.asyncTimeoutMutex.RLock()
	defer fake.asyncTimeoutMutex.RUnlock()
	fake.authenticationEndpointMutex.RLock()
	defer fake.authenticationEndpointMutex.RUnlock()
	fake.cLIVersionMutex.RLock()
	defer fake.cLIVersionMutex.RUnlock()
	fake.clearSessionMutex.RLock()
	defer fake.clearSessionMutex.RUnlock()
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	fake.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	fake.isMinAPIVersionMutex.RLock()
	defer fake.isMinAPIVersionMutex.RUnlock()
	fake.isMinCLIVersionMutex.RLock()
	defer fake.isMinCLIVersionMutex.RUnlock()
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	fake.logCacheEndpointMutex.RLock()
	defer fake.logCacheEndpointMutex.RUnlock()
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	fake.minRecommendedCLIVersionMutex.RLock()
	defer fake.minRecommendedCLIVersionMutex.RUnlock()
	fake.organizationFieldsMutex.RLock()
	defer fake.organizationFieldsMutex.RUnlock()
	fake.pluginReposMutex.RLock()
	defer fake.pluginReposMutex.RUnlock()
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	fake.routingAPIEndpointMutex.RLock()
	defer fake.routingAPIEndpointMutex.RUnlock()
	fake.sSHOAuthClientMutex.RLock()
	defer fake.sSHOAuthClientMutex.RUnlock()
	fake.setAPIEndpointMutex.RLock()
	defer fake.setAPIEndpointMutex.RUnlock()
	fake.setAPIVersionMutex.RLock()
	defer fake.setAPIVersionMutex.RUnlock()
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	fake.setCLIVersionMutex.RLock()
	defer fake.setCLIVersionMutex.RUnlock()
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	fake.setDopplerEndpointMutex.RLock()
	defer fake.setDopplerEndpointMutex.RUnlock()
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	fake.setLogCacheEndpointMutex.RLock()
	defer fake.setLogCacheEndpointMutex.RUnlock()
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	fake.setMinRecommendedCLIVersionMutex.RLock()
	defer fake.setMinRecommendedCLIVersionMutex.RUnlock()
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	fake.setPluginRepoMutex.RLock()
	defer fake.setPluginRepoMutex.RUnlock()
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	fake.setRoutingAPIEndpointMutex.RLock()
	defer fake.setRoutingAPIEndpointMutex.RUnlock()
	fake.setSSHOAuthClientMutex.RLock()
	defer fake.setSSHOAuthClientMutex.RUnlock()
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	fake.setUAAOAuthClientMutex.RLock()
	defer fake.setUAAOAuthClientMutex.RUnlock()
	fake.setUAAOAuthClientSecretMutex.RLock()
	defer fake.setUAAOAuthClientSecretMutex.RUnlock()
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	fake.spaceFieldsMutex.RLock()
	defer fake.spaceFieldsMutex.RUnlock()
	fake.traceMutex.RLock()
	defer fake.traceMutex.RUnlock()
	fake.uAAGrantTypeMutex.RLock()
	defer fake.uAAGrantTypeMutex.RUnlock()
	fake.uAAOAuthClientMutex.RLock()
	defer fake.uAAOAuthClientMutex.RUnlock()
	fake.uAAOAuthClientSecretMutex.RLock()
	defer fake.uAAOAuthClientSecretMutex.RUnlock()
	fake.uaaEndpointMutex.RLock()
	defer fake.uaaEndpointMutex.RUnlock()
	fake.unSetPluginRepoMutex.RLock()
	defer fake.unSetPluginRepoMutex.RUnlock()
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	fake.userGUIDMutex.RLock()
	defer fake.userGUIDMutex.RUnlock()
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeReadWriter) 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 _ coreconfig.ReadWriter = new(FakeReadWriter)
