srs/internal/env/envfakes/fake_proxy_environment.go

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

import (
	"srsx/internal/env"
	"sync"
)

type FakeProxyEnvironment struct {
	DefaultBackendAPIStub        func() string
	defaultBackendAPIMutex       sync.RWMutex
	defaultBackendAPIArgsForCall []struct {
	}
	defaultBackendAPIReturns struct {
		result1 string
	}
	defaultBackendAPIReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendEnabledStub        func() string
	defaultBackendEnabledMutex       sync.RWMutex
	defaultBackendEnabledArgsForCall []struct {
	}
	defaultBackendEnabledReturns struct {
		result1 string
	}
	defaultBackendEnabledReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendHttpStub        func() string
	defaultBackendHttpMutex       sync.RWMutex
	defaultBackendHttpArgsForCall []struct {
	}
	defaultBackendHttpReturns struct {
		result1 string
	}
	defaultBackendHttpReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendIPStub        func() string
	defaultBackendIPMutex       sync.RWMutex
	defaultBackendIPArgsForCall []struct {
	}
	defaultBackendIPReturns struct {
		result1 string
	}
	defaultBackendIPReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendRTCStub        func() string
	defaultBackendRTCMutex       sync.RWMutex
	defaultBackendRTCArgsForCall []struct {
	}
	defaultBackendRTCReturns struct {
		result1 string
	}
	defaultBackendRTCReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendRTMPStub        func() string
	defaultBackendRTMPMutex       sync.RWMutex
	defaultBackendRTMPArgsForCall []struct {
	}
	defaultBackendRTMPReturns struct {
		result1 string
	}
	defaultBackendRTMPReturnsOnCall map[int]struct {
		result1 string
	}
	DefaultBackendSRTStub        func() string
	defaultBackendSRTMutex       sync.RWMutex
	defaultBackendSRTArgsForCall []struct {
	}
	defaultBackendSRTReturns struct {
		result1 string
	}
	defaultBackendSRTReturnsOnCall map[int]struct {
		result1 string
	}
	ForceQuitTimeoutStub        func() string
	forceQuitTimeoutMutex       sync.RWMutex
	forceQuitTimeoutArgsForCall []struct {
	}
	forceQuitTimeoutReturns struct {
		result1 string
	}
	forceQuitTimeoutReturnsOnCall map[int]struct {
		result1 string
	}
	GoPprofStub        func() string
	goPprofMutex       sync.RWMutex
	goPprofArgsForCall []struct {
	}
	goPprofReturns struct {
		result1 string
	}
	goPprofReturnsOnCall map[int]struct {
		result1 string
	}
	GraceQuitTimeoutStub        func() string
	graceQuitTimeoutMutex       sync.RWMutex
	graceQuitTimeoutArgsForCall []struct {
	}
	graceQuitTimeoutReturns struct {
		result1 string
	}
	graceQuitTimeoutReturnsOnCall map[int]struct {
		result1 string
	}
	HttpAPIStub        func() string
	httpAPIMutex       sync.RWMutex
	httpAPIArgsForCall []struct {
	}
	httpAPIReturns struct {
		result1 string
	}
	httpAPIReturnsOnCall map[int]struct {
		result1 string
	}
	HttpServerStub        func() string
	httpServerMutex       sync.RWMutex
	httpServerArgsForCall []struct {
	}
	httpServerReturns struct {
		result1 string
	}
	httpServerReturnsOnCall map[int]struct {
		result1 string
	}
	LoadBalancerTypeStub        func() string
	loadBalancerTypeMutex       sync.RWMutex
	loadBalancerTypeArgsForCall []struct {
	}
	loadBalancerTypeReturns struct {
		result1 string
	}
	loadBalancerTypeReturnsOnCall map[int]struct {
		result1 string
	}
	RedisDBStub        func() string
	redisDBMutex       sync.RWMutex
	redisDBArgsForCall []struct {
	}
	redisDBReturns struct {
		result1 string
	}
	redisDBReturnsOnCall map[int]struct {
		result1 string
	}
	RedisHostStub        func() string
	redisHostMutex       sync.RWMutex
	redisHostArgsForCall []struct {
	}
	redisHostReturns struct {
		result1 string
	}
	redisHostReturnsOnCall map[int]struct {
		result1 string
	}
	RedisPasswordStub        func() string
	redisPasswordMutex       sync.RWMutex
	redisPasswordArgsForCall []struct {
	}
	redisPasswordReturns struct {
		result1 string
	}
	redisPasswordReturnsOnCall map[int]struct {
		result1 string
	}
	RedisPortStub        func() string
	redisPortMutex       sync.RWMutex
	redisPortArgsForCall []struct {
	}
	redisPortReturns struct {
		result1 string
	}
	redisPortReturnsOnCall map[int]struct {
		result1 string
	}
	RtmpServerStub        func() string
	rtmpServerMutex       sync.RWMutex
	rtmpServerArgsForCall []struct {
	}
	rtmpServerReturns struct {
		result1 string
	}
	rtmpServerReturnsOnCall map[int]struct {
		result1 string
	}
	SRTServerStub        func() string
	sRTServerMutex       sync.RWMutex
	sRTServerArgsForCall []struct {
	}
	sRTServerReturns struct {
		result1 string
	}
	sRTServerReturnsOnCall map[int]struct {
		result1 string
	}
	StaticFilesStub        func() string
	staticFilesMutex       sync.RWMutex
	staticFilesArgsForCall []struct {
	}
	staticFilesReturns struct {
		result1 string
	}
	staticFilesReturnsOnCall map[int]struct {
		result1 string
	}
	SystemAPIStub        func() string
	systemAPIMutex       sync.RWMutex
	systemAPIArgsForCall []struct {
	}
	systemAPIReturns struct {
		result1 string
	}
	systemAPIReturnsOnCall map[int]struct {
		result1 string
	}
	WebRTCServerStub        func() string
	webRTCServerMutex       sync.RWMutex
	webRTCServerArgsForCall []struct {
	}
	webRTCServerReturns struct {
		result1 string
	}
	webRTCServerReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeProxyEnvironment) DefaultBackendAPI() string {
	fake.defaultBackendAPIMutex.Lock()
	ret, specificReturn := fake.defaultBackendAPIReturnsOnCall[len(fake.defaultBackendAPIArgsForCall)]
	fake.defaultBackendAPIArgsForCall = append(fake.defaultBackendAPIArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendAPIStub
	fakeReturns := fake.defaultBackendAPIReturns
	fake.recordInvocation("DefaultBackendAPI", []interface{}{})
	fake.defaultBackendAPIMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendAPICallCount() int {
	fake.defaultBackendAPIMutex.RLock()
	defer fake.defaultBackendAPIMutex.RUnlock()
	return len(fake.defaultBackendAPIArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendAPICalls(stub func() string) {
	fake.defaultBackendAPIMutex.Lock()
	defer fake.defaultBackendAPIMutex.Unlock()
	fake.DefaultBackendAPIStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendAPIReturns(result1 string) {
	fake.defaultBackendAPIMutex.Lock()
	defer fake.defaultBackendAPIMutex.Unlock()
	fake.DefaultBackendAPIStub = nil
	fake.defaultBackendAPIReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendAPIReturnsOnCall(i int, result1 string) {
	fake.defaultBackendAPIMutex.Lock()
	defer fake.defaultBackendAPIMutex.Unlock()
	fake.DefaultBackendAPIStub = nil
	if fake.defaultBackendAPIReturnsOnCall == nil {
		fake.defaultBackendAPIReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendAPIReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendEnabled() string {
	fake.defaultBackendEnabledMutex.Lock()
	ret, specificReturn := fake.defaultBackendEnabledReturnsOnCall[len(fake.defaultBackendEnabledArgsForCall)]
	fake.defaultBackendEnabledArgsForCall = append(fake.defaultBackendEnabledArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendEnabledStub
	fakeReturns := fake.defaultBackendEnabledReturns
	fake.recordInvocation("DefaultBackendEnabled", []interface{}{})
	fake.defaultBackendEnabledMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendEnabledCallCount() int {
	fake.defaultBackendEnabledMutex.RLock()
	defer fake.defaultBackendEnabledMutex.RUnlock()
	return len(fake.defaultBackendEnabledArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendEnabledCalls(stub func() string) {
	fake.defaultBackendEnabledMutex.Lock()
	defer fake.defaultBackendEnabledMutex.Unlock()
	fake.DefaultBackendEnabledStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendEnabledReturns(result1 string) {
	fake.defaultBackendEnabledMutex.Lock()
	defer fake.defaultBackendEnabledMutex.Unlock()
	fake.DefaultBackendEnabledStub = nil
	fake.defaultBackendEnabledReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendEnabledReturnsOnCall(i int, result1 string) {
	fake.defaultBackendEnabledMutex.Lock()
	defer fake.defaultBackendEnabledMutex.Unlock()
	fake.DefaultBackendEnabledStub = nil
	if fake.defaultBackendEnabledReturnsOnCall == nil {
		fake.defaultBackendEnabledReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendEnabledReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendHttp() string {
	fake.defaultBackendHttpMutex.Lock()
	ret, specificReturn := fake.defaultBackendHttpReturnsOnCall[len(fake.defaultBackendHttpArgsForCall)]
	fake.defaultBackendHttpArgsForCall = append(fake.defaultBackendHttpArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendHttpStub
	fakeReturns := fake.defaultBackendHttpReturns
	fake.recordInvocation("DefaultBackendHttp", []interface{}{})
	fake.defaultBackendHttpMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendHttpCallCount() int {
	fake.defaultBackendHttpMutex.RLock()
	defer fake.defaultBackendHttpMutex.RUnlock()
	return len(fake.defaultBackendHttpArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendHttpCalls(stub func() string) {
	fake.defaultBackendHttpMutex.Lock()
	defer fake.defaultBackendHttpMutex.Unlock()
	fake.DefaultBackendHttpStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendHttpReturns(result1 string) {
	fake.defaultBackendHttpMutex.Lock()
	defer fake.defaultBackendHttpMutex.Unlock()
	fake.DefaultBackendHttpStub = nil
	fake.defaultBackendHttpReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendHttpReturnsOnCall(i int, result1 string) {
	fake.defaultBackendHttpMutex.Lock()
	defer fake.defaultBackendHttpMutex.Unlock()
	fake.DefaultBackendHttpStub = nil
	if fake.defaultBackendHttpReturnsOnCall == nil {
		fake.defaultBackendHttpReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendHttpReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendIP() string {
	fake.defaultBackendIPMutex.Lock()
	ret, specificReturn := fake.defaultBackendIPReturnsOnCall[len(fake.defaultBackendIPArgsForCall)]
	fake.defaultBackendIPArgsForCall = append(fake.defaultBackendIPArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendIPStub
	fakeReturns := fake.defaultBackendIPReturns
	fake.recordInvocation("DefaultBackendIP", []interface{}{})
	fake.defaultBackendIPMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendIPCallCount() int {
	fake.defaultBackendIPMutex.RLock()
	defer fake.defaultBackendIPMutex.RUnlock()
	return len(fake.defaultBackendIPArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendIPCalls(stub func() string) {
	fake.defaultBackendIPMutex.Lock()
	defer fake.defaultBackendIPMutex.Unlock()
	fake.DefaultBackendIPStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendIPReturns(result1 string) {
	fake.defaultBackendIPMutex.Lock()
	defer fake.defaultBackendIPMutex.Unlock()
	fake.DefaultBackendIPStub = nil
	fake.defaultBackendIPReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendIPReturnsOnCall(i int, result1 string) {
	fake.defaultBackendIPMutex.Lock()
	defer fake.defaultBackendIPMutex.Unlock()
	fake.DefaultBackendIPStub = nil
	if fake.defaultBackendIPReturnsOnCall == nil {
		fake.defaultBackendIPReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendIPReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendRTC() string {
	fake.defaultBackendRTCMutex.Lock()
	ret, specificReturn := fake.defaultBackendRTCReturnsOnCall[len(fake.defaultBackendRTCArgsForCall)]
	fake.defaultBackendRTCArgsForCall = append(fake.defaultBackendRTCArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendRTCStub
	fakeReturns := fake.defaultBackendRTCReturns
	fake.recordInvocation("DefaultBackendRTC", []interface{}{})
	fake.defaultBackendRTCMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendRTCCallCount() int {
	fake.defaultBackendRTCMutex.RLock()
	defer fake.defaultBackendRTCMutex.RUnlock()
	return len(fake.defaultBackendRTCArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendRTCCalls(stub func() string) {
	fake.defaultBackendRTCMutex.Lock()
	defer fake.defaultBackendRTCMutex.Unlock()
	fake.DefaultBackendRTCStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendRTCReturns(result1 string) {
	fake.defaultBackendRTCMutex.Lock()
	defer fake.defaultBackendRTCMutex.Unlock()
	fake.DefaultBackendRTCStub = nil
	fake.defaultBackendRTCReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendRTCReturnsOnCall(i int, result1 string) {
	fake.defaultBackendRTCMutex.Lock()
	defer fake.defaultBackendRTCMutex.Unlock()
	fake.DefaultBackendRTCStub = nil
	if fake.defaultBackendRTCReturnsOnCall == nil {
		fake.defaultBackendRTCReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendRTCReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendRTMP() string {
	fake.defaultBackendRTMPMutex.Lock()
	ret, specificReturn := fake.defaultBackendRTMPReturnsOnCall[len(fake.defaultBackendRTMPArgsForCall)]
	fake.defaultBackendRTMPArgsForCall = append(fake.defaultBackendRTMPArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendRTMPStub
	fakeReturns := fake.defaultBackendRTMPReturns
	fake.recordInvocation("DefaultBackendRTMP", []interface{}{})
	fake.defaultBackendRTMPMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendRTMPCallCount() int {
	fake.defaultBackendRTMPMutex.RLock()
	defer fake.defaultBackendRTMPMutex.RUnlock()
	return len(fake.defaultBackendRTMPArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendRTMPCalls(stub func() string) {
	fake.defaultBackendRTMPMutex.Lock()
	defer fake.defaultBackendRTMPMutex.Unlock()
	fake.DefaultBackendRTMPStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendRTMPReturns(result1 string) {
	fake.defaultBackendRTMPMutex.Lock()
	defer fake.defaultBackendRTMPMutex.Unlock()
	fake.DefaultBackendRTMPStub = nil
	fake.defaultBackendRTMPReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendRTMPReturnsOnCall(i int, result1 string) {
	fake.defaultBackendRTMPMutex.Lock()
	defer fake.defaultBackendRTMPMutex.Unlock()
	fake.DefaultBackendRTMPStub = nil
	if fake.defaultBackendRTMPReturnsOnCall == nil {
		fake.defaultBackendRTMPReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendRTMPReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendSRT() string {
	fake.defaultBackendSRTMutex.Lock()
	ret, specificReturn := fake.defaultBackendSRTReturnsOnCall[len(fake.defaultBackendSRTArgsForCall)]
	fake.defaultBackendSRTArgsForCall = append(fake.defaultBackendSRTArgsForCall, struct {
	}{})
	stub := fake.DefaultBackendSRTStub
	fakeReturns := fake.defaultBackendSRTReturns
	fake.recordInvocation("DefaultBackendSRT", []interface{}{})
	fake.defaultBackendSRTMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) DefaultBackendSRTCallCount() int {
	fake.defaultBackendSRTMutex.RLock()
	defer fake.defaultBackendSRTMutex.RUnlock()
	return len(fake.defaultBackendSRTArgsForCall)
}

func (fake *FakeProxyEnvironment) DefaultBackendSRTCalls(stub func() string) {
	fake.defaultBackendSRTMutex.Lock()
	defer fake.defaultBackendSRTMutex.Unlock()
	fake.DefaultBackendSRTStub = stub
}

func (fake *FakeProxyEnvironment) DefaultBackendSRTReturns(result1 string) {
	fake.defaultBackendSRTMutex.Lock()
	defer fake.defaultBackendSRTMutex.Unlock()
	fake.DefaultBackendSRTStub = nil
	fake.defaultBackendSRTReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) DefaultBackendSRTReturnsOnCall(i int, result1 string) {
	fake.defaultBackendSRTMutex.Lock()
	defer fake.defaultBackendSRTMutex.Unlock()
	fake.DefaultBackendSRTStub = nil
	if fake.defaultBackendSRTReturnsOnCall == nil {
		fake.defaultBackendSRTReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.defaultBackendSRTReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) ForceQuitTimeout() string {
	fake.forceQuitTimeoutMutex.Lock()
	ret, specificReturn := fake.forceQuitTimeoutReturnsOnCall[len(fake.forceQuitTimeoutArgsForCall)]
	fake.forceQuitTimeoutArgsForCall = append(fake.forceQuitTimeoutArgsForCall, struct {
	}{})
	stub := fake.ForceQuitTimeoutStub
	fakeReturns := fake.forceQuitTimeoutReturns
	fake.recordInvocation("ForceQuitTimeout", []interface{}{})
	fake.forceQuitTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) ForceQuitTimeoutCallCount() int {
	fake.forceQuitTimeoutMutex.RLock()
	defer fake.forceQuitTimeoutMutex.RUnlock()
	return len(fake.forceQuitTimeoutArgsForCall)
}

func (fake *FakeProxyEnvironment) ForceQuitTimeoutCalls(stub func() string) {
	fake.forceQuitTimeoutMutex.Lock()
	defer fake.forceQuitTimeoutMutex.Unlock()
	fake.ForceQuitTimeoutStub = stub
}

func (fake *FakeProxyEnvironment) ForceQuitTimeoutReturns(result1 string) {
	fake.forceQuitTimeoutMutex.Lock()
	defer fake.forceQuitTimeoutMutex.Unlock()
	fake.ForceQuitTimeoutStub = nil
	fake.forceQuitTimeoutReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) ForceQuitTimeoutReturnsOnCall(i int, result1 string) {
	fake.forceQuitTimeoutMutex.Lock()
	defer fake.forceQuitTimeoutMutex.Unlock()
	fake.ForceQuitTimeoutStub = nil
	if fake.forceQuitTimeoutReturnsOnCall == nil {
		fake.forceQuitTimeoutReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.forceQuitTimeoutReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) GoPprof() string {
	fake.goPprofMutex.Lock()
	ret, specificReturn := fake.goPprofReturnsOnCall[len(fake.goPprofArgsForCall)]
	fake.goPprofArgsForCall = append(fake.goPprofArgsForCall, struct {
	}{})
	stub := fake.GoPprofStub
	fakeReturns := fake.goPprofReturns
	fake.recordInvocation("GoPprof", []interface{}{})
	fake.goPprofMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) GoPprofCallCount() int {
	fake.goPprofMutex.RLock()
	defer fake.goPprofMutex.RUnlock()
	return len(fake.goPprofArgsForCall)
}

func (fake *FakeProxyEnvironment) GoPprofCalls(stub func() string) {
	fake.goPprofMutex.Lock()
	defer fake.goPprofMutex.Unlock()
	fake.GoPprofStub = stub
}

func (fake *FakeProxyEnvironment) GoPprofReturns(result1 string) {
	fake.goPprofMutex.Lock()
	defer fake.goPprofMutex.Unlock()
	fake.GoPprofStub = nil
	fake.goPprofReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) GoPprofReturnsOnCall(i int, result1 string) {
	fake.goPprofMutex.Lock()
	defer fake.goPprofMutex.Unlock()
	fake.GoPprofStub = nil
	if fake.goPprofReturnsOnCall == nil {
		fake.goPprofReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.goPprofReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) GraceQuitTimeout() string {
	fake.graceQuitTimeoutMutex.Lock()
	ret, specificReturn := fake.graceQuitTimeoutReturnsOnCall[len(fake.graceQuitTimeoutArgsForCall)]
	fake.graceQuitTimeoutArgsForCall = append(fake.graceQuitTimeoutArgsForCall, struct {
	}{})
	stub := fake.GraceQuitTimeoutStub
	fakeReturns := fake.graceQuitTimeoutReturns
	fake.recordInvocation("GraceQuitTimeout", []interface{}{})
	fake.graceQuitTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) GraceQuitTimeoutCallCount() int {
	fake.graceQuitTimeoutMutex.RLock()
	defer fake.graceQuitTimeoutMutex.RUnlock()
	return len(fake.graceQuitTimeoutArgsForCall)
}

func (fake *FakeProxyEnvironment) GraceQuitTimeoutCalls(stub func() string) {
	fake.graceQuitTimeoutMutex.Lock()
	defer fake.graceQuitTimeoutMutex.Unlock()
	fake.GraceQuitTimeoutStub = stub
}

func (fake *FakeProxyEnvironment) GraceQuitTimeoutReturns(result1 string) {
	fake.graceQuitTimeoutMutex.Lock()
	defer fake.graceQuitTimeoutMutex.Unlock()
	fake.GraceQuitTimeoutStub = nil
	fake.graceQuitTimeoutReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) GraceQuitTimeoutReturnsOnCall(i int, result1 string) {
	fake.graceQuitTimeoutMutex.Lock()
	defer fake.graceQuitTimeoutMutex.Unlock()
	fake.GraceQuitTimeoutStub = nil
	if fake.graceQuitTimeoutReturnsOnCall == nil {
		fake.graceQuitTimeoutReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.graceQuitTimeoutReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) HttpAPI() string {
	fake.httpAPIMutex.Lock()
	ret, specificReturn := fake.httpAPIReturnsOnCall[len(fake.httpAPIArgsForCall)]
	fake.httpAPIArgsForCall = append(fake.httpAPIArgsForCall, struct {
	}{})
	stub := fake.HttpAPIStub
	fakeReturns := fake.httpAPIReturns
	fake.recordInvocation("HttpAPI", []interface{}{})
	fake.httpAPIMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) HttpAPICallCount() int {
	fake.httpAPIMutex.RLock()
	defer fake.httpAPIMutex.RUnlock()
	return len(fake.httpAPIArgsForCall)
}

func (fake *FakeProxyEnvironment) HttpAPICalls(stub func() string) {
	fake.httpAPIMutex.Lock()
	defer fake.httpAPIMutex.Unlock()
	fake.HttpAPIStub = stub
}

func (fake *FakeProxyEnvironment) HttpAPIReturns(result1 string) {
	fake.httpAPIMutex.Lock()
	defer fake.httpAPIMutex.Unlock()
	fake.HttpAPIStub = nil
	fake.httpAPIReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) HttpAPIReturnsOnCall(i int, result1 string) {
	fake.httpAPIMutex.Lock()
	defer fake.httpAPIMutex.Unlock()
	fake.HttpAPIStub = nil
	if fake.httpAPIReturnsOnCall == nil {
		fake.httpAPIReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.httpAPIReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) HttpServer() string {
	fake.httpServerMutex.Lock()
	ret, specificReturn := fake.httpServerReturnsOnCall[len(fake.httpServerArgsForCall)]
	fake.httpServerArgsForCall = append(fake.httpServerArgsForCall, struct {
	}{})
	stub := fake.HttpServerStub
	fakeReturns := fake.httpServerReturns
	fake.recordInvocation("HttpServer", []interface{}{})
	fake.httpServerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) HttpServerCallCount() int {
	fake.httpServerMutex.RLock()
	defer fake.httpServerMutex.RUnlock()
	return len(fake.httpServerArgsForCall)
}

func (fake *FakeProxyEnvironment) HttpServerCalls(stub func() string) {
	fake.httpServerMutex.Lock()
	defer fake.httpServerMutex.Unlock()
	fake.HttpServerStub = stub
}

func (fake *FakeProxyEnvironment) HttpServerReturns(result1 string) {
	fake.httpServerMutex.Lock()
	defer fake.httpServerMutex.Unlock()
	fake.HttpServerStub = nil
	fake.httpServerReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) HttpServerReturnsOnCall(i int, result1 string) {
	fake.httpServerMutex.Lock()
	defer fake.httpServerMutex.Unlock()
	fake.HttpServerStub = nil
	if fake.httpServerReturnsOnCall == nil {
		fake.httpServerReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.httpServerReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) LoadBalancerType() string {
	fake.loadBalancerTypeMutex.Lock()
	ret, specificReturn := fake.loadBalancerTypeReturnsOnCall[len(fake.loadBalancerTypeArgsForCall)]
	fake.loadBalancerTypeArgsForCall = append(fake.loadBalancerTypeArgsForCall, struct {
	}{})
	stub := fake.LoadBalancerTypeStub
	fakeReturns := fake.loadBalancerTypeReturns
	fake.recordInvocation("LoadBalancerType", []interface{}{})
	fake.loadBalancerTypeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) LoadBalancerTypeCallCount() int {
	fake.loadBalancerTypeMutex.RLock()
	defer fake.loadBalancerTypeMutex.RUnlock()
	return len(fake.loadBalancerTypeArgsForCall)
}

func (fake *FakeProxyEnvironment) LoadBalancerTypeCalls(stub func() string) {
	fake.loadBalancerTypeMutex.Lock()
	defer fake.loadBalancerTypeMutex.Unlock()
	fake.LoadBalancerTypeStub = stub
}

func (fake *FakeProxyEnvironment) LoadBalancerTypeReturns(result1 string) {
	fake.loadBalancerTypeMutex.Lock()
	defer fake.loadBalancerTypeMutex.Unlock()
	fake.LoadBalancerTypeStub = nil
	fake.loadBalancerTypeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) LoadBalancerTypeReturnsOnCall(i int, result1 string) {
	fake.loadBalancerTypeMutex.Lock()
	defer fake.loadBalancerTypeMutex.Unlock()
	fake.LoadBalancerTypeStub = nil
	if fake.loadBalancerTypeReturnsOnCall == nil {
		fake.loadBalancerTypeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.loadBalancerTypeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisDB() string {
	fake.redisDBMutex.Lock()
	ret, specificReturn := fake.redisDBReturnsOnCall[len(fake.redisDBArgsForCall)]
	fake.redisDBArgsForCall = append(fake.redisDBArgsForCall, struct {
	}{})
	stub := fake.RedisDBStub
	fakeReturns := fake.redisDBReturns
	fake.recordInvocation("RedisDB", []interface{}{})
	fake.redisDBMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) RedisDBCallCount() int {
	fake.redisDBMutex.RLock()
	defer fake.redisDBMutex.RUnlock()
	return len(fake.redisDBArgsForCall)
}

func (fake *FakeProxyEnvironment) RedisDBCalls(stub func() string) {
	fake.redisDBMutex.Lock()
	defer fake.redisDBMutex.Unlock()
	fake.RedisDBStub = stub
}

func (fake *FakeProxyEnvironment) RedisDBReturns(result1 string) {
	fake.redisDBMutex.Lock()
	defer fake.redisDBMutex.Unlock()
	fake.RedisDBStub = nil
	fake.redisDBReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisDBReturnsOnCall(i int, result1 string) {
	fake.redisDBMutex.Lock()
	defer fake.redisDBMutex.Unlock()
	fake.RedisDBStub = nil
	if fake.redisDBReturnsOnCall == nil {
		fake.redisDBReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.redisDBReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisHost() string {
	fake.redisHostMutex.Lock()
	ret, specificReturn := fake.redisHostReturnsOnCall[len(fake.redisHostArgsForCall)]
	fake.redisHostArgsForCall = append(fake.redisHostArgsForCall, struct {
	}{})
	stub := fake.RedisHostStub
	fakeReturns := fake.redisHostReturns
	fake.recordInvocation("RedisHost", []interface{}{})
	fake.redisHostMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) RedisHostCallCount() int {
	fake.redisHostMutex.RLock()
	defer fake.redisHostMutex.RUnlock()
	return len(fake.redisHostArgsForCall)
}

func (fake *FakeProxyEnvironment) RedisHostCalls(stub func() string) {
	fake.redisHostMutex.Lock()
	defer fake.redisHostMutex.Unlock()
	fake.RedisHostStub = stub
}

func (fake *FakeProxyEnvironment) RedisHostReturns(result1 string) {
	fake.redisHostMutex.Lock()
	defer fake.redisHostMutex.Unlock()
	fake.RedisHostStub = nil
	fake.redisHostReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisHostReturnsOnCall(i int, result1 string) {
	fake.redisHostMutex.Lock()
	defer fake.redisHostMutex.Unlock()
	fake.RedisHostStub = nil
	if fake.redisHostReturnsOnCall == nil {
		fake.redisHostReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.redisHostReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisPassword() string {
	fake.redisPasswordMutex.Lock()
	ret, specificReturn := fake.redisPasswordReturnsOnCall[len(fake.redisPasswordArgsForCall)]
	fake.redisPasswordArgsForCall = append(fake.redisPasswordArgsForCall, struct {
	}{})
	stub := fake.RedisPasswordStub
	fakeReturns := fake.redisPasswordReturns
	fake.recordInvocation("RedisPassword", []interface{}{})
	fake.redisPasswordMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) RedisPasswordCallCount() int {
	fake.redisPasswordMutex.RLock()
	defer fake.redisPasswordMutex.RUnlock()
	return len(fake.redisPasswordArgsForCall)
}

func (fake *FakeProxyEnvironment) RedisPasswordCalls(stub func() string) {
	fake.redisPasswordMutex.Lock()
	defer fake.redisPasswordMutex.Unlock()
	fake.RedisPasswordStub = stub
}

func (fake *FakeProxyEnvironment) RedisPasswordReturns(result1 string) {
	fake.redisPasswordMutex.Lock()
	defer fake.redisPasswordMutex.Unlock()
	fake.RedisPasswordStub = nil
	fake.redisPasswordReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisPasswordReturnsOnCall(i int, result1 string) {
	fake.redisPasswordMutex.Lock()
	defer fake.redisPasswordMutex.Unlock()
	fake.RedisPasswordStub = nil
	if fake.redisPasswordReturnsOnCall == nil {
		fake.redisPasswordReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.redisPasswordReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisPort() string {
	fake.redisPortMutex.Lock()
	ret, specificReturn := fake.redisPortReturnsOnCall[len(fake.redisPortArgsForCall)]
	fake.redisPortArgsForCall = append(fake.redisPortArgsForCall, struct {
	}{})
	stub := fake.RedisPortStub
	fakeReturns := fake.redisPortReturns
	fake.recordInvocation("RedisPort", []interface{}{})
	fake.redisPortMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) RedisPortCallCount() int {
	fake.redisPortMutex.RLock()
	defer fake.redisPortMutex.RUnlock()
	return len(fake.redisPortArgsForCall)
}

func (fake *FakeProxyEnvironment) RedisPortCalls(stub func() string) {
	fake.redisPortMutex.Lock()
	defer fake.redisPortMutex.Unlock()
	fake.RedisPortStub = stub
}

func (fake *FakeProxyEnvironment) RedisPortReturns(result1 string) {
	fake.redisPortMutex.Lock()
	defer fake.redisPortMutex.Unlock()
	fake.RedisPortStub = nil
	fake.redisPortReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RedisPortReturnsOnCall(i int, result1 string) {
	fake.redisPortMutex.Lock()
	defer fake.redisPortMutex.Unlock()
	fake.RedisPortStub = nil
	if fake.redisPortReturnsOnCall == nil {
		fake.redisPortReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.redisPortReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RtmpServer() string {
	fake.rtmpServerMutex.Lock()
	ret, specificReturn := fake.rtmpServerReturnsOnCall[len(fake.rtmpServerArgsForCall)]
	fake.rtmpServerArgsForCall = append(fake.rtmpServerArgsForCall, struct {
	}{})
	stub := fake.RtmpServerStub
	fakeReturns := fake.rtmpServerReturns
	fake.recordInvocation("RtmpServer", []interface{}{})
	fake.rtmpServerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) RtmpServerCallCount() int {
	fake.rtmpServerMutex.RLock()
	defer fake.rtmpServerMutex.RUnlock()
	return len(fake.rtmpServerArgsForCall)
}

func (fake *FakeProxyEnvironment) RtmpServerCalls(stub func() string) {
	fake.rtmpServerMutex.Lock()
	defer fake.rtmpServerMutex.Unlock()
	fake.RtmpServerStub = stub
}

func (fake *FakeProxyEnvironment) RtmpServerReturns(result1 string) {
	fake.rtmpServerMutex.Lock()
	defer fake.rtmpServerMutex.Unlock()
	fake.RtmpServerStub = nil
	fake.rtmpServerReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) RtmpServerReturnsOnCall(i int, result1 string) {
	fake.rtmpServerMutex.Lock()
	defer fake.rtmpServerMutex.Unlock()
	fake.RtmpServerStub = nil
	if fake.rtmpServerReturnsOnCall == nil {
		fake.rtmpServerReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.rtmpServerReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) SRTServer() string {
	fake.sRTServerMutex.Lock()
	ret, specificReturn := fake.sRTServerReturnsOnCall[len(fake.sRTServerArgsForCall)]
	fake.sRTServerArgsForCall = append(fake.sRTServerArgsForCall, struct {
	}{})
	stub := fake.SRTServerStub
	fakeReturns := fake.sRTServerReturns
	fake.recordInvocation("SRTServer", []interface{}{})
	fake.sRTServerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) SRTServerCallCount() int {
	fake.sRTServerMutex.RLock()
	defer fake.sRTServerMutex.RUnlock()
	return len(fake.sRTServerArgsForCall)
}

func (fake *FakeProxyEnvironment) SRTServerCalls(stub func() string) {
	fake.sRTServerMutex.Lock()
	defer fake.sRTServerMutex.Unlock()
	fake.SRTServerStub = stub
}

func (fake *FakeProxyEnvironment) SRTServerReturns(result1 string) {
	fake.sRTServerMutex.Lock()
	defer fake.sRTServerMutex.Unlock()
	fake.SRTServerStub = nil
	fake.sRTServerReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) SRTServerReturnsOnCall(i int, result1 string) {
	fake.sRTServerMutex.Lock()
	defer fake.sRTServerMutex.Unlock()
	fake.SRTServerStub = nil
	if fake.sRTServerReturnsOnCall == nil {
		fake.sRTServerReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.sRTServerReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) StaticFiles() string {
	fake.staticFilesMutex.Lock()
	ret, specificReturn := fake.staticFilesReturnsOnCall[len(fake.staticFilesArgsForCall)]
	fake.staticFilesArgsForCall = append(fake.staticFilesArgsForCall, struct {
	}{})
	stub := fake.StaticFilesStub
	fakeReturns := fake.staticFilesReturns
	fake.recordInvocation("StaticFiles", []interface{}{})
	fake.staticFilesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) StaticFilesCallCount() int {
	fake.staticFilesMutex.RLock()
	defer fake.staticFilesMutex.RUnlock()
	return len(fake.staticFilesArgsForCall)
}

func (fake *FakeProxyEnvironment) StaticFilesCalls(stub func() string) {
	fake.staticFilesMutex.Lock()
	defer fake.staticFilesMutex.Unlock()
	fake.StaticFilesStub = stub
}

func (fake *FakeProxyEnvironment) StaticFilesReturns(result1 string) {
	fake.staticFilesMutex.Lock()
	defer fake.staticFilesMutex.Unlock()
	fake.StaticFilesStub = nil
	fake.staticFilesReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) StaticFilesReturnsOnCall(i int, result1 string) {
	fake.staticFilesMutex.Lock()
	defer fake.staticFilesMutex.Unlock()
	fake.StaticFilesStub = nil
	if fake.staticFilesReturnsOnCall == nil {
		fake.staticFilesReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.staticFilesReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) SystemAPI() string {
	fake.systemAPIMutex.Lock()
	ret, specificReturn := fake.systemAPIReturnsOnCall[len(fake.systemAPIArgsForCall)]
	fake.systemAPIArgsForCall = append(fake.systemAPIArgsForCall, struct {
	}{})
	stub := fake.SystemAPIStub
	fakeReturns := fake.systemAPIReturns
	fake.recordInvocation("SystemAPI", []interface{}{})
	fake.systemAPIMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) SystemAPICallCount() int {
	fake.systemAPIMutex.RLock()
	defer fake.systemAPIMutex.RUnlock()
	return len(fake.systemAPIArgsForCall)
}

func (fake *FakeProxyEnvironment) SystemAPICalls(stub func() string) {
	fake.systemAPIMutex.Lock()
	defer fake.systemAPIMutex.Unlock()
	fake.SystemAPIStub = stub
}

func (fake *FakeProxyEnvironment) SystemAPIReturns(result1 string) {
	fake.systemAPIMutex.Lock()
	defer fake.systemAPIMutex.Unlock()
	fake.SystemAPIStub = nil
	fake.systemAPIReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) SystemAPIReturnsOnCall(i int, result1 string) {
	fake.systemAPIMutex.Lock()
	defer fake.systemAPIMutex.Unlock()
	fake.SystemAPIStub = nil
	if fake.systemAPIReturnsOnCall == nil {
		fake.systemAPIReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.systemAPIReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) WebRTCServer() string {
	fake.webRTCServerMutex.Lock()
	ret, specificReturn := fake.webRTCServerReturnsOnCall[len(fake.webRTCServerArgsForCall)]
	fake.webRTCServerArgsForCall = append(fake.webRTCServerArgsForCall, struct {
	}{})
	stub := fake.WebRTCServerStub
	fakeReturns := fake.webRTCServerReturns
	fake.recordInvocation("WebRTCServer", []interface{}{})
	fake.webRTCServerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeProxyEnvironment) WebRTCServerCallCount() int {
	fake.webRTCServerMutex.RLock()
	defer fake.webRTCServerMutex.RUnlock()
	return len(fake.webRTCServerArgsForCall)
}

func (fake *FakeProxyEnvironment) WebRTCServerCalls(stub func() string) {
	fake.webRTCServerMutex.Lock()
	defer fake.webRTCServerMutex.Unlock()
	fake.WebRTCServerStub = stub
}

func (fake *FakeProxyEnvironment) WebRTCServerReturns(result1 string) {
	fake.webRTCServerMutex.Lock()
	defer fake.webRTCServerMutex.Unlock()
	fake.WebRTCServerStub = nil
	fake.webRTCServerReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) WebRTCServerReturnsOnCall(i int, result1 string) {
	fake.webRTCServerMutex.Lock()
	defer fake.webRTCServerMutex.Unlock()
	fake.WebRTCServerStub = nil
	if fake.webRTCServerReturnsOnCall == nil {
		fake.webRTCServerReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.webRTCServerReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProxyEnvironment) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeProxyEnvironment) 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 _ env.ProxyEnvironment = new(FakeProxyEnvironment)