fake_repository.go

// This file was generated by counterfeiter
package fakes

import (
	"sync"

	"github.com/cloudfoundry/cli/cf/configuration/core_config"
	"github.com/cloudfoundry/cli/cf/models"
)

type FakeReadWriter struct {
	ApiEndpointStub        func() string
	apiEndpointMutex       sync.RWMutex
	apiEndpointArgsForCall []struct{}
	apiEndpointReturns     struct {
		result1 string
	}
	ApiVersionStub        func() string
	apiVersionMutex       sync.RWMutex
	apiVersionArgsForCall []struct{}
	apiVersionReturns     struct {
		result1 string
	}
	HasAPIEndpointStub        func() bool
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct{}
	hasAPIEndpointReturns     struct {
		result1 bool
	}
	AuthenticationEndpointStub        func() string
	authenticationEndpointMutex       sync.RWMutex
	authenticationEndpointArgsForCall []struct{}
	authenticationEndpointReturns     struct {
		result1 string
	}
	LoggregatorEndpointStub        func() string
	loggregatorEndpointMutex       sync.RWMutex
	loggregatorEndpointArgsForCall []struct{}
	loggregatorEndpointReturns     struct {
		result1 string
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct{}
	dopplerEndpointReturns     struct {
		result1 string
	}
	UaaEndpointStub        func() string
	uaaEndpointMutex       sync.RWMutex
	uaaEndpointArgsForCall []struct{}
	uaaEndpointReturns     struct {
		result1 string
	}
	RoutingApiEndpointStub        func() string
	routingApiEndpointMutex       sync.RWMutex
	routingApiEndpointArgsForCall []struct{}
	routingApiEndpointReturns     struct {
		result1 string
	}
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct{}
	accessTokenReturns     struct {
		result1 string
	}
	SSHOAuthClientStub        func() string
	sSHOAuthClientMutex       sync.RWMutex
	sSHOAuthClientArgsForCall []struct{}
	sSHOAuthClientReturns     struct {
		result1 string
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct{}
	refreshTokenReturns     struct {
		result1 string
	}
	OrganizationFieldsStub        func() models.OrganizationFields
	organizationFieldsMutex       sync.RWMutex
	organizationFieldsArgsForCall []struct{}
	organizationFieldsReturns     struct {
		result1 models.OrganizationFields
	}
	HasOrganizationStub        func() bool
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct{}
	hasOrganizationReturns     struct {
		result1 bool
	}
	SpaceFieldsStub        func() models.SpaceFields
	spaceFieldsMutex       sync.RWMutex
	spaceFieldsArgsForCall []struct{}
	spaceFieldsReturns     struct {
		result1 models.SpaceFields
	}
	HasSpaceStub        func() bool
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct{}
	hasSpaceReturns     struct {
		result1 bool
	}
	UsernameStub        func() string
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct{}
	usernameReturns     struct {
		result1 string
	}
	UserGuidStub        func() string
	userGuidMutex       sync.RWMutex
	userGuidArgsForCall []struct{}
	userGuidReturns     struct {
		result1 string
	}
	UserEmailStub        func() string
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct{}
	userEmailReturns     struct {
		result1 string
	}
	IsLoggedInStub        func() bool
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct{}
	isLoggedInReturns     struct {
		result1 bool
	}
	IsSSLDisabledStub        func() bool
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct{}
	isSSLDisabledReturns     struct {
		result1 bool
	}
	IsMinApiVersionStub        func(string) bool
	isMinApiVersionMutex       sync.RWMutex
	isMinApiVersionArgsForCall []struct {
		arg1 string
	}
	isMinApiVersionReturns struct {
		result1 bool
	}
	IsMinCliVersionStub        func(string) bool
	isMinCliVersionMutex       sync.RWMutex
	isMinCliVersionArgsForCall []struct {
		arg1 string
	}
	isMinCliVersionReturns struct {
		result1 bool
	}
	MinCliVersionStub        func() string
	minCliVersionMutex       sync.RWMutex
	minCliVersionArgsForCall []struct{}
	minCliVersionReturns     struct {
		result1 string
	}
	MinRecommendedCliVersionStub        func() string
	minRecommendedCliVersionMutex       sync.RWMutex
	minRecommendedCliVersionArgsForCall []struct{}
	minRecommendedCliVersionReturns     struct {
		result1 string
	}
	AsyncTimeoutStub        func() uint
	asyncTimeoutMutex       sync.RWMutex
	asyncTimeoutArgsForCall []struct{}
	asyncTimeoutReturns     struct {
		result1 uint
	}
	TraceStub        func() string
	traceMutex       sync.RWMutex
	traceArgsForCall []struct{}
	traceReturns     struct {
		result1 string
	}
	ColorEnabledStub        func() string
	colorEnabledMutex       sync.RWMutex
	colorEnabledArgsForCall []struct{}
	colorEnabledReturns     struct {
		result1 string
	}
	LocaleStub        func() string
	localeMutex       sync.RWMutex
	localeArgsForCall []struct{}
	localeReturns     struct {
		result1 string
	}
	PluginReposStub        func() []models.PluginRepo
	pluginReposMutex       sync.RWMutex
	pluginReposArgsForCall []struct{}
	pluginReposReturns     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
	}
	SetLoggregatorEndpointStub        func(string)
	setLoggregatorEndpointMutex       sync.RWMutex
	setLoggregatorEndpointArgsForCall []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
	}
	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
	}
}

func (fake *FakeReadWriter) ApiEndpoint() string {
	fake.apiEndpointMutex.Lock()
	fake.apiEndpointArgsForCall = append(fake.apiEndpointArgsForCall, struct{}{})
	fake.apiEndpointMutex.Unlock()
	if fake.ApiEndpointStub != nil {
		return fake.ApiEndpointStub()
	} else {
		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) ApiVersion() string {
	fake.apiVersionMutex.Lock()
	fake.apiVersionArgsForCall = append(fake.apiVersionArgsForCall, struct{}{})
	fake.apiVersionMutex.Unlock()
	if fake.ApiVersionStub != nil {
		return fake.ApiVersionStub()
	} else {
		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) HasAPIEndpoint() bool {
	fake.hasAPIEndpointMutex.Lock()
	fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct{}{})
	fake.hasAPIEndpointMutex.Unlock()
	if fake.HasAPIEndpointStub != nil {
		return fake.HasAPIEndpointStub()
	} else {
		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) AuthenticationEndpoint() string {
	fake.authenticationEndpointMutex.Lock()
	fake.authenticationEndpointArgsForCall = append(fake.authenticationEndpointArgsForCall, struct{}{})
	fake.authenticationEndpointMutex.Unlock()
	if fake.AuthenticationEndpointStub != nil {
		return fake.AuthenticationEndpointStub()
	} else {
		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) LoggregatorEndpoint() string {
	fake.loggregatorEndpointMutex.Lock()
	fake.loggregatorEndpointArgsForCall = append(fake.loggregatorEndpointArgsForCall, struct{}{})
	fake.loggregatorEndpointMutex.Unlock()
	if fake.LoggregatorEndpointStub != nil {
		return fake.LoggregatorEndpointStub()
	} else {
		return fake.loggregatorEndpointReturns.result1
	}
}

func (fake *FakeReadWriter) LoggregatorEndpointCallCount() int {
	fake.loggregatorEndpointMutex.RLock()
	defer fake.loggregatorEndpointMutex.RUnlock()
	return len(fake.loggregatorEndpointArgsForCall)
}

func (fake *FakeReadWriter) LoggregatorEndpointReturns(result1 string) {
	fake.LoggregatorEndpointStub = nil
	fake.loggregatorEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReadWriter) DopplerEndpoint() string {
	fake.dopplerEndpointMutex.Lock()
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	} else {
		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) UaaEndpoint() string {
	fake.uaaEndpointMutex.Lock()
	fake.uaaEndpointArgsForCall = append(fake.uaaEndpointArgsForCall, struct{}{})
	fake.uaaEndpointMutex.Unlock()
	if fake.UaaEndpointStub != nil {
		return fake.UaaEndpointStub()
	} else {
		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) RoutingApiEndpoint() string {
	fake.routingApiEndpointMutex.Lock()
	fake.routingApiEndpointArgsForCall = append(fake.routingApiEndpointArgsForCall, struct{}{})
	fake.routingApiEndpointMutex.Unlock()
	if fake.RoutingApiEndpointStub != nil {
		return fake.RoutingApiEndpointStub()
	} else {
		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) AccessToken() string {
	fake.accessTokenMutex.Lock()
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct{}{})
	fake.accessTokenMutex.Unlock()
	if fake.AccessTokenStub != nil {
		return fake.AccessTokenStub()
	} else {
		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) SSHOAuthClient() string {
	fake.sSHOAuthClientMutex.Lock()
	fake.sSHOAuthClientArgsForCall = append(fake.sSHOAuthClientArgsForCall, struct{}{})
	fake.sSHOAuthClientMutex.Unlock()
	if fake.SSHOAuthClientStub != nil {
		return fake.SSHOAuthClientStub()
	} else {
		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) RefreshToken() string {
	fake.refreshTokenMutex.Lock()
	fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct{}{})
	fake.refreshTokenMutex.Unlock()
	if fake.RefreshTokenStub != nil {
		return fake.RefreshTokenStub()
	} else {
		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) OrganizationFields() models.OrganizationFields {
	fake.organizationFieldsMutex.Lock()
	fake.organizationFieldsArgsForCall = append(fake.organizationFieldsArgsForCall, struct{}{})
	fake.organizationFieldsMutex.Unlock()
	if fake.OrganizationFieldsStub != nil {
		return fake.OrganizationFieldsStub()
	} else {
		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) HasOrganization() bool {
	fake.hasOrganizationMutex.Lock()
	fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct{}{})
	fake.hasOrganizationMutex.Unlock()
	if fake.HasOrganizationStub != nil {
		return fake.HasOrganizationStub()
	} else {
		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) SpaceFields() models.SpaceFields {
	fake.spaceFieldsMutex.Lock()
	fake.spaceFieldsArgsForCall = append(fake.spaceFieldsArgsForCall, struct{}{})
	fake.spaceFieldsMutex.Unlock()
	if fake.SpaceFieldsStub != nil {
		return fake.SpaceFieldsStub()
	} else {
		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) HasSpace() bool {
	fake.hasSpaceMutex.Lock()
	fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct{}{})
	fake.hasSpaceMutex.Unlock()
	if fake.HasSpaceStub != nil {
		return fake.HasSpaceStub()
	} else {
		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) Username() string {
	fake.usernameMutex.Lock()
	fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct{}{})
	fake.usernameMutex.Unlock()
	if fake.UsernameStub != nil {
		return fake.UsernameStub()
	} else {
		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) UserGuid() string {
	fake.userGuidMutex.Lock()
	fake.userGuidArgsForCall = append(fake.userGuidArgsForCall, struct{}{})
	fake.userGuidMutex.Unlock()
	if fake.UserGuidStub != nil {
		return fake.UserGuidStub()
	} else {
		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) UserEmail() string {
	fake.userEmailMutex.Lock()
	fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct{}{})
	fake.userEmailMutex.Unlock()
	if fake.UserEmailStub != nil {
		return fake.UserEmailStub()
	} else {
		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) IsLoggedIn() bool {
	fake.isLoggedInMutex.Lock()
	fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct{}{})
	fake.isLoggedInMutex.Unlock()
	if fake.IsLoggedInStub != nil {
		return fake.IsLoggedInStub()
	} else {
		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) IsSSLDisabled() bool {
	fake.isSSLDisabledMutex.Lock()
	fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct{}{})
	fake.isSSLDisabledMutex.Unlock()
	if fake.IsSSLDisabledStub != nil {
		return fake.IsSSLDisabledStub()
	} else {
		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) IsMinApiVersion(arg1 string) bool {
	fake.isMinApiVersionMutex.Lock()
	fake.isMinApiVersionArgsForCall = append(fake.isMinApiVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.isMinApiVersionMutex.Unlock()
	if fake.IsMinApiVersionStub != nil {
		return fake.IsMinApiVersionStub(arg1)
	} else {
		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) string {
	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) IsMinCliVersion(arg1 string) bool {
	fake.isMinCliVersionMutex.Lock()
	fake.isMinCliVersionArgsForCall = append(fake.isMinCliVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.isMinCliVersionMutex.Unlock()
	if fake.IsMinCliVersionStub != nil {
		return fake.IsMinCliVersionStub(arg1)
	} else {
		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) MinCliVersion() string {
	fake.minCliVersionMutex.Lock()
	fake.minCliVersionArgsForCall = append(fake.minCliVersionArgsForCall, struct{}{})
	fake.minCliVersionMutex.Unlock()
	if fake.MinCliVersionStub != nil {
		return fake.MinCliVersionStub()
	} else {
		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) MinRecommendedCliVersion() string {
	fake.minRecommendedCliVersionMutex.Lock()
	fake.minRecommendedCliVersionArgsForCall = append(fake.minRecommendedCliVersionArgsForCall, struct{}{})
	fake.minRecommendedCliVersionMutex.Unlock()
	if fake.MinRecommendedCliVersionStub != nil {
		return fake.MinRecommendedCliVersionStub()
	} else {
		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) AsyncTimeout() uint {
	fake.asyncTimeoutMutex.Lock()
	fake.asyncTimeoutArgsForCall = append(fake.asyncTimeoutArgsForCall, struct{}{})
	fake.asyncTimeoutMutex.Unlock()
	if fake.AsyncTimeoutStub != nil {
		return fake.AsyncTimeoutStub()
	} else {
		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) Trace() string {
	fake.traceMutex.Lock()
	fake.traceArgsForCall = append(fake.traceArgsForCall, struct{}{})
	fake.traceMutex.Unlock()
	if fake.TraceStub != nil {
		return fake.TraceStub()
	} else {
		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) ColorEnabled() string {
	fake.colorEnabledMutex.Lock()
	fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct{}{})
	fake.colorEnabledMutex.Unlock()
	if fake.ColorEnabledStub != nil {
		return fake.ColorEnabledStub()
	} else {
		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) Locale() string {
	fake.localeMutex.Lock()
	fake.localeArgsForCall = append(fake.localeArgsForCall, struct{}{})
	fake.localeMutex.Unlock()
	if fake.LocaleStub != nil {
		return fake.LocaleStub()
	} else {
		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) PluginRepos() []models.PluginRepo {
	fake.pluginReposMutex.Lock()
	fake.pluginReposArgsForCall = append(fake.pluginReposArgsForCall, struct{}{})
	fake.pluginReposMutex.Unlock()
	if fake.PluginReposStub != nil {
		return fake.PluginReposStub()
	} else {
		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) ClearSession() {
	fake.clearSessionMutex.Lock()
	fake.clearSessionArgsForCall = append(fake.clearSessionArgsForCall, struct{}{})
	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.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.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.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.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.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) SetLoggregatorEndpoint(arg1 string) {
	fake.setLoggregatorEndpointMutex.Lock()
	fake.setLoggregatorEndpointArgsForCall = append(fake.setLoggregatorEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.setLoggregatorEndpointMutex.Unlock()
	if fake.SetLoggregatorEndpointStub != nil {
		fake.SetLoggregatorEndpointStub(arg1)
	}
}

func (fake *FakeReadWriter) SetLoggregatorEndpointCallCount() int {
	fake.setLoggregatorEndpointMutex.RLock()
	defer fake.setLoggregatorEndpointMutex.RUnlock()
	return len(fake.setLoggregatorEndpointArgsForCall)
}

func (fake *FakeReadWriter) SetLoggregatorEndpointArgsForCall(i int) string {
	fake.setLoggregatorEndpointMutex.RLock()
	defer fake.setLoggregatorEndpointMutex.RUnlock()
	return fake.setLoggregatorEndpointArgsForCall[i].arg1
}

func (fake *FakeReadWriter) SetDopplerEndpoint(arg1 string) {
	fake.setDopplerEndpointMutex.Lock()
	fake.setDopplerEndpointArgsForCall = append(fake.setDopplerEndpointArgsForCall, struct {
		arg1 string
	}{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.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.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.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) SetSSHOAuthClient(arg1 string) {
	fake.setSSHOAuthClientMutex.Lock()
	fake.setSSHOAuthClientArgsForCall = append(fake.setSSHOAuthClientArgsForCall, struct {
		arg1 string
	}{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.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.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.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.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.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.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.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.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.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.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
}

var _ core_config.ReadWriter = new(FakeReadWriter)