fake_read_writer.go

// 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"
)

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
	}
	HasAPIEndpointStub        func() bool
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct{}
	hasAPIEndpointReturns     struct {
		result1 bool
	}
	hasAPIEndpointReturnsOnCall map[int]struct {
		result1 bool
	}
	AuthenticationEndpointStub        func() string
	authenticationEndpointMutex       sync.RWMutex
	authenticationEndpointArgsForCall []struct{}
	authenticationEndpointReturns     struct {
		result1 string
	}
	authenticationEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct{}
	dopplerEndpointReturns     struct {
		result1 string
	}
	dopplerEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	UaaEndpointStub        func() string
	uaaEndpointMutex       sync.RWMutex
	uaaEndpointArgsForCall []struct{}
	uaaEndpointReturns     struct {
		result1 string
	}
	uaaEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	RoutingAPIEndpointStub        func() string
	routingAPIEndpointMutex       sync.RWMutex
	routingAPIEndpointArgsForCall []struct{}
	routingAPIEndpointReturns     struct {
		result1 string
	}
	routingAPIEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct{}
	accessTokenReturns     struct {
		result1 string
	}
	accessTokenReturnsOnCall 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
	}
	SSHOAuthClientStub        func() string
	sSHOAuthClientMutex       sync.RWMutex
	sSHOAuthClientArgsForCall []struct{}
	sSHOAuthClientReturns     struct {
		result1 string
	}
	sSHOAuthClientReturnsOnCall map[int]struct {
		result1 string
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct{}
	refreshTokenReturns     struct {
		result1 string
	}
	refreshTokenReturnsOnCall 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
	}
	HasOrganizationStub        func() bool
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct{}
	hasOrganizationReturns     struct {
		result1 bool
	}
	hasOrganizationReturnsOnCall map[int]struct {
		result1 bool
	}
	SpaceFieldsStub        func() models.SpaceFields
	spaceFieldsMutex       sync.RWMutex
	spaceFieldsArgsForCall []struct{}
	spaceFieldsReturns     struct {
		result1 models.SpaceFields
	}
	spaceFieldsReturnsOnCall map[int]struct {
		result1 models.SpaceFields
	}
	HasSpaceStub        func() bool
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct{}
	hasSpaceReturns     struct {
		result1 bool
	}
	hasSpaceReturnsOnCall map[int]struct {
		result1 bool
	}
	UsernameStub        func() string
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct{}
	usernameReturns     struct {
		result1 string
	}
	usernameReturnsOnCall map[int]struct {
		result1 string
	}
	UserGUIDStub        func() string
	userGUIDMutex       sync.RWMutex
	userGUIDArgsForCall []struct{}
	userGUIDReturns     struct {
		result1 string
	}
	userGUIDReturnsOnCall map[int]struct {
		result1 string
	}
	UserEmailStub        func() string
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct{}
	userEmailReturns     struct {
		result1 string
	}
	userEmailReturnsOnCall map[int]struct {
		result1 string
	}
	IsLoggedInStub        func() bool
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct{}
	isLoggedInReturns     struct {
		result1 bool
	}
	isLoggedInReturnsOnCall map[int]struct {
		result1 bool
	}
	IsSSLDisabledStub        func() bool
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct{}
	isSSLDisabledReturns     struct {
		result1 bool
	}
	isSSLDisabledReturnsOnCall 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
	}
	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
	}
	CLIVersionStub        func() string
	cLIVersionMutex       sync.RWMutex
	cLIVersionArgsForCall []struct{}
	cLIVersionReturns     struct {
		result1 string
	}
	cLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	AsyncTimeoutStub        func() uint
	asyncTimeoutMutex       sync.RWMutex
	asyncTimeoutArgsForCall []struct{}
	asyncTimeoutReturns     struct {
		result1 uint
	}
	asyncTimeoutReturnsOnCall map[int]struct {
		result1 uint
	}
	TraceStub        func() string
	traceMutex       sync.RWMutex
	traceArgsForCall []struct{}
	traceReturns     struct {
		result1 string
	}
	traceReturnsOnCall map[int]struct {
		result1 string
	}
	ColorEnabledStub        func() string
	colorEnabledMutex       sync.RWMutex
	colorEnabledArgsForCall []struct{}
	colorEnabledReturns     struct {
		result1 string
	}
	colorEnabledReturnsOnCall map[int]struct {
		result1 string
	}
	LocaleStub        func() string
	localeMutex       sync.RWMutex
	localeArgsForCall []struct{}
	localeReturns     struct {
		result1 string
	}
	localeReturnsOnCall map[int]struct {
		result1 string
	}
	PluginReposStub        func() []models.PluginRepo
	pluginReposMutex       sync.RWMutex
	pluginReposArgsForCall []struct{}
	pluginReposReturns     struct {
		result1 []models.PluginRepo
	}
	pluginReposReturnsOnCall map[int]struct {
		result1 []models.PluginRepo
	}
	ClearSessionStub          func()
	clearSessionMutex         sync.RWMutex
	clearSessionArgsForCall   []struct{}
	SetAPIEndpointStub        func(string)
	setAPIEndpointMutex       sync.RWMutex
	setAPIEndpointArgsForCall []struct {
		arg1 string
	}
	SetAPIVersionStub        func(string)
	setAPIVersionMutex       sync.RWMutex
	setAPIVersionArgsForCall []struct {
		arg1 string
	}
	SetMinCLIVersionStub        func(string)
	setMinCLIVersionMutex       sync.RWMutex
	setMinCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetMinRecommendedCLIVersionStub        func(string)
	setMinRecommendedCLIVersionMutex       sync.RWMutex
	setMinRecommendedCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetAuthenticationEndpointStub        func(string)
	setAuthenticationEndpointMutex       sync.RWMutex
	setAuthenticationEndpointArgsForCall []struct {
		arg1 string
	}
	SetDopplerEndpointStub        func(string)
	setDopplerEndpointMutex       sync.RWMutex
	setDopplerEndpointArgsForCall []struct {
		arg1 string
	}
	SetUaaEndpointStub        func(string)
	setUaaEndpointMutex       sync.RWMutex
	setUaaEndpointArgsForCall []struct {
		arg1 string
	}
	SetRoutingAPIEndpointStub        func(string)
	setRoutingAPIEndpointMutex       sync.RWMutex
	setRoutingAPIEndpointArgsForCall []struct {
		arg1 string
	}
	SetAccessTokenStub        func(string)
	setAccessTokenMutex       sync.RWMutex
	setAccessTokenArgsForCall []struct {
		arg1 string
	}
	SetUAAOAuthClientStub        func(string)
	setUAAOAuthClientMutex       sync.RWMutex
	setUAAOAuthClientArgsForCall []struct {
		arg1 string
	}
	SetUAAOAuthClientSecretStub        func(string)
	setUAAOAuthClientSecretMutex       sync.RWMutex
	setUAAOAuthClientSecretArgsForCall []struct {
		arg1 string
	}
	SetSSHOAuthClientStub        func(string)
	setSSHOAuthClientMutex       sync.RWMutex
	setSSHOAuthClientArgsForCall []struct {
		arg1 string
	}
	SetRefreshTokenStub        func(string)
	setRefreshTokenMutex       sync.RWMutex
	setRefreshTokenArgsForCall []struct {
		arg1 string
	}
	SetOrganizationFieldsStub        func(models.OrganizationFields)
	setOrganizationFieldsMutex       sync.RWMutex
	setOrganizationFieldsArgsForCall []struct {
		arg1 models.OrganizationFields
	}
	SetSpaceFieldsStub        func(models.SpaceFields)
	setSpaceFieldsMutex       sync.RWMutex
	setSpaceFieldsArgsForCall []struct {
		arg1 models.SpaceFields
	}
	SetSSLDisabledStub        func(bool)
	setSSLDisabledMutex       sync.RWMutex
	setSSLDisabledArgsForCall []struct {
		arg1 bool
	}
	SetAsyncTimeoutStub        func(uint)
	setAsyncTimeoutMutex       sync.RWMutex
	setAsyncTimeoutArgsForCall []struct {
		arg1 uint
	}
	SetTraceStub        func(string)
	setTraceMutex       sync.RWMutex
	setTraceArgsForCall []struct {
		arg1 string
	}
	SetColorEnabledStub        func(string)
	setColorEnabledMutex       sync.RWMutex
	setColorEnabledArgsForCall []struct {
		arg1 string
	}
	SetLocaleStub        func(string)
	setLocaleMutex       sync.RWMutex
	setLocaleArgsForCall []struct {
		arg1 string
	}
	SetPluginRepoStub        func(models.PluginRepo)
	setPluginRepoMutex       sync.RWMutex
	setPluginRepoArgsForCall []struct {
		arg1 models.PluginRepo
	}
	UnSetPluginRepoStub        func(int)
	unSetPluginRepoMutex       sync.RWMutex
	unSetPluginRepoArgsForCall []struct {
		arg1 int
	}
	SetCLIVersionStub        func(string)
	setCLIVersionMutex       sync.RWMutex
	setCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetUAAGrantTypeStub        func(string)
	setUAAGrantTypeMutex       sync.RWMutex
	setUAAGrantTypeArgsForCall []struct {
		arg1 string
	}
	UAAGrantTypeStub        func() string
	uAAGrantTypeMutex       sync.RWMutex
	uAAGrantTypeArgsForCall []struct{}
	uAAGrantTypeReturns     struct {
		result1 string
	}
	uAAGrantTypeReturnsOnCall 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
	}
	return fake.aPIEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) APIEndpointReturnsOnCall(i int, result1 string) {
	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
	}
	return fake.aPIVersionReturns.result1
}

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

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

func (fake *FakeReadWriter) APIVersionReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.hasAPIEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) HasAPIEndpointReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.authenticationEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) AuthenticationEndpointReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.dopplerEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) DopplerEndpointReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.uaaEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) UaaEndpointReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.routingAPIEndpointReturns.result1
}

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

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

func (fake *FakeReadWriter) RoutingAPIEndpointReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.accessTokenReturns.result1
}

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

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

func (fake *FakeReadWriter) AccessTokenReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.uAAOAuthClientReturns.result1
}

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

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

func (fake *FakeReadWriter) UAAOAuthClientReturnsOnCall(i int, result1 string) {
	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
	}
	return fake.uAAOAuthClientSecretReturns.result1
}

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

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

func (fake *FakeReadWriter) UAAOAuthClientSecretReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.sSHOAuthClientReturns.result1
}

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

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

func (fake *FakeReadWriter) SSHOAuthClientReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.refreshTokenReturns.result1
}

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

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

func (fake *FakeReadWriter) RefreshTokenReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.organizationFieldsReturns.result1
}

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

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

func (fake *FakeReadWriter) OrganizationFieldsReturnsOnCall(i int, result1 models.OrganizationFields) {
	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) 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
	}
	return fake.hasOrganizationReturns.result1
}

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

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

func (fake *FakeReadWriter) HasOrganizationReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.spaceFieldsReturns.result1
}

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

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

func (fake *FakeReadWriter) SpaceFieldsReturnsOnCall(i int, result1 models.SpaceFields) {
	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) 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
	}
	return fake.hasSpaceReturns.result1
}

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

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

func (fake *FakeReadWriter) HasSpaceReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.usernameReturns.result1
}

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

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

func (fake *FakeReadWriter) UsernameReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.userGUIDReturns.result1
}

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

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

func (fake *FakeReadWriter) UserGUIDReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.userEmailReturns.result1
}

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

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

func (fake *FakeReadWriter) UserEmailReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.isLoggedInReturns.result1
}

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

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

func (fake *FakeReadWriter) IsLoggedInReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.isSSLDisabledReturns.result1
}

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

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

func (fake *FakeReadWriter) IsSSLDisabledReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.isMinAPIVersionReturns.result1
}

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

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

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

func (fake *FakeReadWriter) IsMinAPIVersionReturnsOnCall(i int, result1 bool) {
	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
	}
	return fake.isMinCLIVersionReturns.result1
}

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

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

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

func (fake *FakeReadWriter) IsMinCLIVersionReturnsOnCall(i int, result1 bool) {
	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) 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
	}
	return fake.minCLIVersionReturns.result1
}

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

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

func (fake *FakeReadWriter) MinCLIVersionReturnsOnCall(i int, result1 string) {
	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
	}
	return fake.minRecommendedCLIVersionReturns.result1
}

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

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

func (fake *FakeReadWriter) MinRecommendedCLIVersionReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.cLIVersionReturns.result1
}

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

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

func (fake *FakeReadWriter) CLIVersionReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.asyncTimeoutReturns.result1
}

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

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

func (fake *FakeReadWriter) AsyncTimeoutReturnsOnCall(i int, result1 uint) {
	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) 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
	}
	return fake.traceReturns.result1
}

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

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

func (fake *FakeReadWriter) TraceReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.colorEnabledReturns.result1
}

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

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

func (fake *FakeReadWriter) ColorEnabledReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.localeReturns.result1
}

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

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

func (fake *FakeReadWriter) LocaleReturnsOnCall(i int, result1 string) {
	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) 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
	}
	return fake.pluginReposReturns.result1
}

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

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

func (fake *FakeReadWriter) PluginReposReturnsOnCall(i int, result1 []models.PluginRepo) {
	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) 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) 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) SetAPIEndpointArgsForCall(i int) string {
	fake.setAPIEndpointMutex.RLock()
	defer fake.setAPIEndpointMutex.RUnlock()
	return fake.setAPIEndpointArgsForCall[i].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) SetAPIVersionArgsForCall(i int) string {
	fake.setAPIVersionMutex.RLock()
	defer fake.setAPIVersionMutex.RUnlock()
	return fake.setAPIVersionArgsForCall[i].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) SetMinCLIVersionArgsForCall(i int) string {
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	return fake.setMinCLIVersionArgsForCall[i].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) SetMinRecommendedCLIVersionArgsForCall(i int) string {
	fake.setMinRecommendedCLIVersionMutex.RLock()
	defer fake.setMinRecommendedCLIVersionMutex.RUnlock()
	return fake.setMinRecommendedCLIVersionArgsForCall[i].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) SetAuthenticationEndpointArgsForCall(i int) string {
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	return fake.setAuthenticationEndpointArgsForCall[i].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) SetDopplerEndpointArgsForCall(i int) string {
	fake.setDopplerEndpointMutex.RLock()
	defer fake.setDopplerEndpointMutex.RUnlock()
	return fake.setDopplerEndpointArgsForCall[i].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) SetUaaEndpointArgsForCall(i int) string {
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	return fake.setUaaEndpointArgsForCall[i].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) SetRoutingAPIEndpointArgsForCall(i int) string {
	fake.setRoutingAPIEndpointMutex.RLock()
	defer fake.setRoutingAPIEndpointMutex.RUnlock()
	return fake.setRoutingAPIEndpointArgsForCall[i].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) SetAccessTokenArgsForCall(i int) string {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	return fake.setAccessTokenArgsForCall[i].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) SetUAAOAuthClientArgsForCall(i int) string {
	fake.setUAAOAuthClientMutex.RLock()
	defer fake.setUAAOAuthClientMutex.RUnlock()
	return fake.setUAAOAuthClientArgsForCall[i].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) SetUAAOAuthClientSecretArgsForCall(i int) string {
	fake.setUAAOAuthClientSecretMutex.RLock()
	defer fake.setUAAOAuthClientSecretMutex.RUnlock()
	return fake.setUAAOAuthClientSecretArgsForCall[i].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) SetSSHOAuthClientArgsForCall(i int) string {
	fake.setSSHOAuthClientMutex.RLock()
	defer fake.setSSHOAuthClientMutex.RUnlock()
	return fake.setSSHOAuthClientArgsForCall[i].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) SetRefreshTokenArgsForCall(i int) string {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	return fake.setRefreshTokenArgsForCall[i].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) SetOrganizationFieldsArgsForCall(i int) models.OrganizationFields {
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	return fake.setOrganizationFieldsArgsForCall[i].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) SetSpaceFieldsArgsForCall(i int) models.SpaceFields {
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	return fake.setSpaceFieldsArgsForCall[i].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) SetSSLDisabledArgsForCall(i int) bool {
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	return fake.setSSLDisabledArgsForCall[i].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) SetAsyncTimeoutArgsForCall(i int) uint {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	return fake.setAsyncTimeoutArgsForCall[i].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) SetTraceArgsForCall(i int) string {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	return fake.setTraceArgsForCall[i].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) SetColorEnabledArgsForCall(i int) string {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	return fake.setColorEnabledArgsForCall[i].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) SetLocaleArgsForCall(i int) string {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	return fake.setLocaleArgsForCall[i].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) SetPluginRepoArgsForCall(i int) models.PluginRepo {
	fake.setPluginRepoMutex.RLock()
	defer fake.setPluginRepoMutex.RUnlock()
	return fake.setPluginRepoArgsForCall[i].arg1
}

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) UnSetPluginRepoArgsForCall(i int) int {
	fake.unSetPluginRepoMutex.RLock()
	defer fake.unSetPluginRepoMutex.RUnlock()
	return fake.unSetPluginRepoArgsForCall[i].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) SetCLIVersionArgsForCall(i int) string {
	fake.setCLIVersionMutex.RLock()
	defer fake.setCLIVersionMutex.RUnlock()
	return fake.setCLIVersionArgsForCall[i].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) SetUAAGrantTypeArgsForCall(i int) string {
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	return fake.setUAAGrantTypeArgsForCall[i].arg1
}

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
	}
	return fake.uAAGrantTypeReturns.result1
}

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

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

func (fake *FakeReadWriter) UAAGrantTypeReturnsOnCall(i int, result1 string) {
	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) 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.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	fake.authenticationEndpointMutex.RLock()
	defer fake.authenticationEndpointMutex.RUnlock()
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	fake.uaaEndpointMutex.RLock()
	defer fake.uaaEndpointMutex.RUnlock()
	fake.routingAPIEndpointMutex.RLock()
	defer fake.routingAPIEndpointMutex.RUnlock()
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	fake.uAAOAuthClientMutex.RLock()
	defer fake.uAAOAuthClientMutex.RUnlock()
	fake.uAAOAuthClientSecretMutex.RLock()
	defer fake.uAAOAuthClientSecretMutex.RUnlock()
	fake.sSHOAuthClientMutex.RLock()
	defer fake.sSHOAuthClientMutex.RUnlock()
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	fake.organizationFieldsMutex.RLock()
	defer fake.organizationFieldsMutex.RUnlock()
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	fake.spaceFieldsMutex.RLock()
	defer fake.spaceFieldsMutex.RUnlock()
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	fake.userGUIDMutex.RLock()
	defer fake.userGUIDMutex.RUnlock()
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	fake.isMinAPIVersionMutex.RLock()
	defer fake.isMinAPIVersionMutex.RUnlock()
	fake.isMinCLIVersionMutex.RLock()
	defer fake.isMinCLIVersionMutex.RUnlock()
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	fake.minRecommendedCLIVersionMutex.RLock()
	defer fake.minRecommendedCLIVersionMutex.RUnlock()
	fake.cLIVersionMutex.RLock()
	defer fake.cLIVersionMutex.RUnlock()
	fake.asyncTimeoutMutex.RLock()
	defer fake.asyncTimeoutMutex.RUnlock()
	fake.traceMutex.RLock()
	defer fake.traceMutex.RUnlock()
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	fake.pluginReposMutex.RLock()
	defer fake.pluginReposMutex.RUnlock()
	fake.clearSessionMutex.RLock()
	defer fake.clearSessionMutex.RUnlock()
	fake.setAPIEndpointMutex.RLock()
	defer fake.setAPIEndpointMutex.RUnlock()
	fake.setAPIVersionMutex.RLock()
	defer fake.setAPIVersionMutex.RUnlock()
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	fake.setMinRecommendedCLIVersionMutex.RLock()
	defer fake.setMinRecommendedCLIVersionMutex.RUnlock()
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	fake.setDopplerEndpointMutex.RLock()
	defer fake.setDopplerEndpointMutex.RUnlock()
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	fake.setRoutingAPIEndpointMutex.RLock()
	defer fake.setRoutingAPIEndpointMutex.RUnlock()
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	fake.setUAAOAuthClientMutex.RLock()
	defer fake.setUAAOAuthClientMutex.RUnlock()
	fake.setUAAOAuthClientSecretMutex.RLock()
	defer fake.setUAAOAuthClientSecretMutex.RUnlock()
	fake.setSSHOAuthClientMutex.RLock()
	defer fake.setSSHOAuthClientMutex.RUnlock()
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	fake.setPluginRepoMutex.RLock()
	defer fake.setPluginRepoMutex.RUnlock()
	fake.unSetPluginRepoMutex.RLock()
	defer fake.unSetPluginRepoMutex.RUnlock()
	fake.setCLIVersionMutex.RLock()
	defer fake.setCLIVersionMutex.RUnlock()
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	fake.uAAGrantTypeMutex.RLock()
	defer fake.uAAGrantTypeMutex.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)