fake_conn.go

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

import (
	"io"
	"net"
	"sync"
	"time"

	"github.com/eltelon/fluent-forward-go/fluent/client/ws/ext"
	"github.com/gorilla/websocket"
)

type FakeConn struct {
	CloseStub        func() error
	closeMutex       sync.RWMutex
	closeArgsForCall []struct {
	}
	closeReturns struct {
		result1 error
	}
	closeReturnsOnCall map[int]struct {
		result1 error
	}
	CloseHandlerStub        func() func(code int, text string) error
	closeHandlerMutex       sync.RWMutex
	closeHandlerArgsForCall []struct {
	}
	closeHandlerReturns struct {
		result1 func(code int, text string) error
	}
	closeHandlerReturnsOnCall map[int]struct {
		result1 func(code int, text string) error
	}
	EnableWriteCompressionStub        func(bool)
	enableWriteCompressionMutex       sync.RWMutex
	enableWriteCompressionArgsForCall []struct {
		arg1 bool
	}
	LocalAddrStub        func() net.Addr
	localAddrMutex       sync.RWMutex
	localAddrArgsForCall []struct {
	}
	localAddrReturns struct {
		result1 net.Addr
	}
	localAddrReturnsOnCall map[int]struct {
		result1 net.Addr
	}
	NextReaderStub        func() (int, io.Reader, error)
	nextReaderMutex       sync.RWMutex
	nextReaderArgsForCall []struct {
	}
	nextReaderReturns struct {
		result1 int
		result2 io.Reader
		result3 error
	}
	nextReaderReturnsOnCall map[int]struct {
		result1 int
		result2 io.Reader
		result3 error
	}
	NextWriterStub        func(int) (io.WriteCloser, error)
	nextWriterMutex       sync.RWMutex
	nextWriterArgsForCall []struct {
		arg1 int
	}
	nextWriterReturns struct {
		result1 io.WriteCloser
		result2 error
	}
	nextWriterReturnsOnCall map[int]struct {
		result1 io.WriteCloser
		result2 error
	}
	PingHandlerStub        func() func(appData string) error
	pingHandlerMutex       sync.RWMutex
	pingHandlerArgsForCall []struct {
	}
	pingHandlerReturns struct {
		result1 func(appData string) error
	}
	pingHandlerReturnsOnCall map[int]struct {
		result1 func(appData string) error
	}
	PongHandlerStub        func() func(appData string) error
	pongHandlerMutex       sync.RWMutex
	pongHandlerArgsForCall []struct {
	}
	pongHandlerReturns struct {
		result1 func(appData string) error
	}
	pongHandlerReturnsOnCall map[int]struct {
		result1 func(appData string) error
	}
	ReadMessageStub        func() (int, []byte, error)
	readMessageMutex       sync.RWMutex
	readMessageArgsForCall []struct {
	}
	readMessageReturns struct {
		result1 int
		result2 []byte
		result3 error
	}
	readMessageReturnsOnCall map[int]struct {
		result1 int
		result2 []byte
		result3 error
	}
	RemoteAddrStub        func() net.Addr
	remoteAddrMutex       sync.RWMutex
	remoteAddrArgsForCall []struct {
	}
	remoteAddrReturns struct {
		result1 net.Addr
	}
	remoteAddrReturnsOnCall map[int]struct {
		result1 net.Addr
	}
	SetCloseHandlerStub        func(func(code int, text string) error)
	setCloseHandlerMutex       sync.RWMutex
	setCloseHandlerArgsForCall []struct {
		arg1 func(code int, text string) error
	}
	SetCompressionLevelStub        func(int) error
	setCompressionLevelMutex       sync.RWMutex
	setCompressionLevelArgsForCall []struct {
		arg1 int
	}
	setCompressionLevelReturns struct {
		result1 error
	}
	setCompressionLevelReturnsOnCall map[int]struct {
		result1 error
	}
	SetPingHandlerStub        func(func(appData string) error)
	setPingHandlerMutex       sync.RWMutex
	setPingHandlerArgsForCall []struct {
		arg1 func(appData string) error
	}
	SetPongHandlerStub        func(func(appData string) error)
	setPongHandlerMutex       sync.RWMutex
	setPongHandlerArgsForCall []struct {
		arg1 func(appData string) error
	}
	SetReadDeadlineStub        func(time.Time) error
	setReadDeadlineMutex       sync.RWMutex
	setReadDeadlineArgsForCall []struct {
		arg1 time.Time
	}
	setReadDeadlineReturns struct {
		result1 error
	}
	setReadDeadlineReturnsOnCall map[int]struct {
		result1 error
	}
	SetReadLimitStub        func(int64)
	setReadLimitMutex       sync.RWMutex
	setReadLimitArgsForCall []struct {
		arg1 int64
	}
	SetWriteDeadlineStub        func(time.Time) error
	setWriteDeadlineMutex       sync.RWMutex
	setWriteDeadlineArgsForCall []struct {
		arg1 time.Time
	}
	setWriteDeadlineReturns struct {
		result1 error
	}
	setWriteDeadlineReturnsOnCall map[int]struct {
		result1 error
	}
	SubprotocolStub        func() string
	subprotocolMutex       sync.RWMutex
	subprotocolArgsForCall []struct {
	}
	subprotocolReturns struct {
		result1 string
	}
	subprotocolReturnsOnCall map[int]struct {
		result1 string
	}
	UnderlyingConnStub        func() net.Conn
	underlyingConnMutex       sync.RWMutex
	underlyingConnArgsForCall []struct {
	}
	underlyingConnReturns struct {
		result1 net.Conn
	}
	underlyingConnReturnsOnCall map[int]struct {
		result1 net.Conn
	}
	WriteControlStub        func(int, []byte, time.Time) error
	writeControlMutex       sync.RWMutex
	writeControlArgsForCall []struct {
		arg1 int
		arg2 []byte
		arg3 time.Time
	}
	writeControlReturns struct {
		result1 error
	}
	writeControlReturnsOnCall map[int]struct {
		result1 error
	}
	WriteMessageStub        func(int, []byte) error
	writeMessageMutex       sync.RWMutex
	writeMessageArgsForCall []struct {
		arg1 int
		arg2 []byte
	}
	writeMessageReturns struct {
		result1 error
	}
	writeMessageReturnsOnCall map[int]struct {
		result1 error
	}
	WritePreparedMessageStub        func(*websocket.PreparedMessage) error
	writePreparedMessageMutex       sync.RWMutex
	writePreparedMessageArgsForCall []struct {
		arg1 *websocket.PreparedMessage
	}
	writePreparedMessageReturns struct {
		result1 error
	}
	writePreparedMessageReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeConn) Close() error {
	fake.closeMutex.Lock()
	ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)]
	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
	}{})
	stub := fake.CloseStub
	fakeReturns := fake.closeReturns
	fake.recordInvocation("Close", []interface{}{})
	fake.closeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

func (fake *FakeConn) CloseCalls(stub func() error) {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.CloseStub = stub
}

func (fake *FakeConn) CloseReturns(result1 error) {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.CloseStub = nil
	fake.closeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) CloseReturnsOnCall(i int, result1 error) {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.CloseStub = nil
	if fake.closeReturnsOnCall == nil {
		fake.closeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.closeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) CloseHandler() func(code int, text string) error {
	fake.closeHandlerMutex.Lock()
	ret, specificReturn := fake.closeHandlerReturnsOnCall[len(fake.closeHandlerArgsForCall)]
	fake.closeHandlerArgsForCall = append(fake.closeHandlerArgsForCall, struct {
	}{})
	stub := fake.CloseHandlerStub
	fakeReturns := fake.closeHandlerReturns
	fake.recordInvocation("CloseHandler", []interface{}{})
	fake.closeHandlerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) CloseHandlerCallCount() int {
	fake.closeHandlerMutex.RLock()
	defer fake.closeHandlerMutex.RUnlock()
	return len(fake.closeHandlerArgsForCall)
}

func (fake *FakeConn) CloseHandlerCalls(stub func() func(code int, text string) error) {
	fake.closeHandlerMutex.Lock()
	defer fake.closeHandlerMutex.Unlock()
	fake.CloseHandlerStub = stub
}

func (fake *FakeConn) CloseHandlerReturns(result1 func(code int, text string) error) {
	fake.closeHandlerMutex.Lock()
	defer fake.closeHandlerMutex.Unlock()
	fake.CloseHandlerStub = nil
	fake.closeHandlerReturns = struct {
		result1 func(code int, text string) error
	}{result1}
}

func (fake *FakeConn) CloseHandlerReturnsOnCall(i int, result1 func(code int, text string) error) {
	fake.closeHandlerMutex.Lock()
	defer fake.closeHandlerMutex.Unlock()
	fake.CloseHandlerStub = nil
	if fake.closeHandlerReturnsOnCall == nil {
		fake.closeHandlerReturnsOnCall = make(map[int]struct {
			result1 func(code int, text string) error
		})
	}
	fake.closeHandlerReturnsOnCall[i] = struct {
		result1 func(code int, text string) error
	}{result1}
}

func (fake *FakeConn) EnableWriteCompression(arg1 bool) {
	fake.enableWriteCompressionMutex.Lock()
	fake.enableWriteCompressionArgsForCall = append(fake.enableWriteCompressionArgsForCall, struct {
		arg1 bool
	}{arg1})
	stub := fake.EnableWriteCompressionStub
	fake.recordInvocation("EnableWriteCompression", []interface{}{arg1})
	fake.enableWriteCompressionMutex.Unlock()
	if stub != nil {
		fake.EnableWriteCompressionStub(arg1)
	}
}

func (fake *FakeConn) EnableWriteCompressionCallCount() int {
	fake.enableWriteCompressionMutex.RLock()
	defer fake.enableWriteCompressionMutex.RUnlock()
	return len(fake.enableWriteCompressionArgsForCall)
}

func (fake *FakeConn) EnableWriteCompressionCalls(stub func(bool)) {
	fake.enableWriteCompressionMutex.Lock()
	defer fake.enableWriteCompressionMutex.Unlock()
	fake.EnableWriteCompressionStub = stub
}

func (fake *FakeConn) EnableWriteCompressionArgsForCall(i int) bool {
	fake.enableWriteCompressionMutex.RLock()
	defer fake.enableWriteCompressionMutex.RUnlock()
	argsForCall := fake.enableWriteCompressionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) LocalAddr() net.Addr {
	fake.localAddrMutex.Lock()
	ret, specificReturn := fake.localAddrReturnsOnCall[len(fake.localAddrArgsForCall)]
	fake.localAddrArgsForCall = append(fake.localAddrArgsForCall, struct {
	}{})
	stub := fake.LocalAddrStub
	fakeReturns := fake.localAddrReturns
	fake.recordInvocation("LocalAddr", []interface{}{})
	fake.localAddrMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) LocalAddrCallCount() int {
	fake.localAddrMutex.RLock()
	defer fake.localAddrMutex.RUnlock()
	return len(fake.localAddrArgsForCall)
}

func (fake *FakeConn) LocalAddrCalls(stub func() net.Addr) {
	fake.localAddrMutex.Lock()
	defer fake.localAddrMutex.Unlock()
	fake.LocalAddrStub = stub
}

func (fake *FakeConn) LocalAddrReturns(result1 net.Addr) {
	fake.localAddrMutex.Lock()
	defer fake.localAddrMutex.Unlock()
	fake.LocalAddrStub = nil
	fake.localAddrReturns = struct {
		result1 net.Addr
	}{result1}
}

func (fake *FakeConn) LocalAddrReturnsOnCall(i int, result1 net.Addr) {
	fake.localAddrMutex.Lock()
	defer fake.localAddrMutex.Unlock()
	fake.LocalAddrStub = nil
	if fake.localAddrReturnsOnCall == nil {
		fake.localAddrReturnsOnCall = make(map[int]struct {
			result1 net.Addr
		})
	}
	fake.localAddrReturnsOnCall[i] = struct {
		result1 net.Addr
	}{result1}
}

func (fake *FakeConn) NextReader() (int, io.Reader, error) {
	fake.nextReaderMutex.Lock()
	ret, specificReturn := fake.nextReaderReturnsOnCall[len(fake.nextReaderArgsForCall)]
	fake.nextReaderArgsForCall = append(fake.nextReaderArgsForCall, struct {
	}{})
	stub := fake.NextReaderStub
	fakeReturns := fake.nextReaderReturns
	fake.recordInvocation("NextReader", []interface{}{})
	fake.nextReaderMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeConn) NextReaderCallCount() int {
	fake.nextReaderMutex.RLock()
	defer fake.nextReaderMutex.RUnlock()
	return len(fake.nextReaderArgsForCall)
}

func (fake *FakeConn) NextReaderCalls(stub func() (int, io.Reader, error)) {
	fake.nextReaderMutex.Lock()
	defer fake.nextReaderMutex.Unlock()
	fake.NextReaderStub = stub
}

func (fake *FakeConn) NextReaderReturns(result1 int, result2 io.Reader, result3 error) {
	fake.nextReaderMutex.Lock()
	defer fake.nextReaderMutex.Unlock()
	fake.NextReaderStub = nil
	fake.nextReaderReturns = struct {
		result1 int
		result2 io.Reader
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeConn) NextReaderReturnsOnCall(i int, result1 int, result2 io.Reader, result3 error) {
	fake.nextReaderMutex.Lock()
	defer fake.nextReaderMutex.Unlock()
	fake.NextReaderStub = nil
	if fake.nextReaderReturnsOnCall == nil {
		fake.nextReaderReturnsOnCall = make(map[int]struct {
			result1 int
			result2 io.Reader
			result3 error
		})
	}
	fake.nextReaderReturnsOnCall[i] = struct {
		result1 int
		result2 io.Reader
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeConn) NextWriter(arg1 int) (io.WriteCloser, error) {
	fake.nextWriterMutex.Lock()
	ret, specificReturn := fake.nextWriterReturnsOnCall[len(fake.nextWriterArgsForCall)]
	fake.nextWriterArgsForCall = append(fake.nextWriterArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.NextWriterStub
	fakeReturns := fake.nextWriterReturns
	fake.recordInvocation("NextWriter", []interface{}{arg1})
	fake.nextWriterMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConn) NextWriterCallCount() int {
	fake.nextWriterMutex.RLock()
	defer fake.nextWriterMutex.RUnlock()
	return len(fake.nextWriterArgsForCall)
}

func (fake *FakeConn) NextWriterCalls(stub func(int) (io.WriteCloser, error)) {
	fake.nextWriterMutex.Lock()
	defer fake.nextWriterMutex.Unlock()
	fake.NextWriterStub = stub
}

func (fake *FakeConn) NextWriterArgsForCall(i int) int {
	fake.nextWriterMutex.RLock()
	defer fake.nextWriterMutex.RUnlock()
	argsForCall := fake.nextWriterArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) NextWriterReturns(result1 io.WriteCloser, result2 error) {
	fake.nextWriterMutex.Lock()
	defer fake.nextWriterMutex.Unlock()
	fake.NextWriterStub = nil
	fake.nextWriterReturns = struct {
		result1 io.WriteCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) NextWriterReturnsOnCall(i int, result1 io.WriteCloser, result2 error) {
	fake.nextWriterMutex.Lock()
	defer fake.nextWriterMutex.Unlock()
	fake.NextWriterStub = nil
	if fake.nextWriterReturnsOnCall == nil {
		fake.nextWriterReturnsOnCall = make(map[int]struct {
			result1 io.WriteCloser
			result2 error
		})
	}
	fake.nextWriterReturnsOnCall[i] = struct {
		result1 io.WriteCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) PingHandler() func(appData string) error {
	fake.pingHandlerMutex.Lock()
	ret, specificReturn := fake.pingHandlerReturnsOnCall[len(fake.pingHandlerArgsForCall)]
	fake.pingHandlerArgsForCall = append(fake.pingHandlerArgsForCall, struct {
	}{})
	stub := fake.PingHandlerStub
	fakeReturns := fake.pingHandlerReturns
	fake.recordInvocation("PingHandler", []interface{}{})
	fake.pingHandlerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) PingHandlerCallCount() int {
	fake.pingHandlerMutex.RLock()
	defer fake.pingHandlerMutex.RUnlock()
	return len(fake.pingHandlerArgsForCall)
}

func (fake *FakeConn) PingHandlerCalls(stub func() func(appData string) error) {
	fake.pingHandlerMutex.Lock()
	defer fake.pingHandlerMutex.Unlock()
	fake.PingHandlerStub = stub
}

func (fake *FakeConn) PingHandlerReturns(result1 func(appData string) error) {
	fake.pingHandlerMutex.Lock()
	defer fake.pingHandlerMutex.Unlock()
	fake.PingHandlerStub = nil
	fake.pingHandlerReturns = struct {
		result1 func(appData string) error
	}{result1}
}

func (fake *FakeConn) PingHandlerReturnsOnCall(i int, result1 func(appData string) error) {
	fake.pingHandlerMutex.Lock()
	defer fake.pingHandlerMutex.Unlock()
	fake.PingHandlerStub = nil
	if fake.pingHandlerReturnsOnCall == nil {
		fake.pingHandlerReturnsOnCall = make(map[int]struct {
			result1 func(appData string) error
		})
	}
	fake.pingHandlerReturnsOnCall[i] = struct {
		result1 func(appData string) error
	}{result1}
}

func (fake *FakeConn) PongHandler() func(appData string) error {
	fake.pongHandlerMutex.Lock()
	ret, specificReturn := fake.pongHandlerReturnsOnCall[len(fake.pongHandlerArgsForCall)]
	fake.pongHandlerArgsForCall = append(fake.pongHandlerArgsForCall, struct {
	}{})
	stub := fake.PongHandlerStub
	fakeReturns := fake.pongHandlerReturns
	fake.recordInvocation("PongHandler", []interface{}{})
	fake.pongHandlerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) PongHandlerCallCount() int {
	fake.pongHandlerMutex.RLock()
	defer fake.pongHandlerMutex.RUnlock()
	return len(fake.pongHandlerArgsForCall)
}

func (fake *FakeConn) PongHandlerCalls(stub func() func(appData string) error) {
	fake.pongHandlerMutex.Lock()
	defer fake.pongHandlerMutex.Unlock()
	fake.PongHandlerStub = stub
}

func (fake *FakeConn) PongHandlerReturns(result1 func(appData string) error) {
	fake.pongHandlerMutex.Lock()
	defer fake.pongHandlerMutex.Unlock()
	fake.PongHandlerStub = nil
	fake.pongHandlerReturns = struct {
		result1 func(appData string) error
	}{result1}
}

func (fake *FakeConn) PongHandlerReturnsOnCall(i int, result1 func(appData string) error) {
	fake.pongHandlerMutex.Lock()
	defer fake.pongHandlerMutex.Unlock()
	fake.PongHandlerStub = nil
	if fake.pongHandlerReturnsOnCall == nil {
		fake.pongHandlerReturnsOnCall = make(map[int]struct {
			result1 func(appData string) error
		})
	}
	fake.pongHandlerReturnsOnCall[i] = struct {
		result1 func(appData string) error
	}{result1}
}

func (fake *FakeConn) ReadMessage() (int, []byte, error) {
	fake.readMessageMutex.Lock()
	ret, specificReturn := fake.readMessageReturnsOnCall[len(fake.readMessageArgsForCall)]
	fake.readMessageArgsForCall = append(fake.readMessageArgsForCall, struct {
	}{})
	stub := fake.ReadMessageStub
	fakeReturns := fake.readMessageReturns
	fake.recordInvocation("ReadMessage", []interface{}{})
	fake.readMessageMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeConn) ReadMessageCallCount() int {
	fake.readMessageMutex.RLock()
	defer fake.readMessageMutex.RUnlock()
	return len(fake.readMessageArgsForCall)
}

func (fake *FakeConn) ReadMessageCalls(stub func() (int, []byte, error)) {
	fake.readMessageMutex.Lock()
	defer fake.readMessageMutex.Unlock()
	fake.ReadMessageStub = stub
}

func (fake *FakeConn) ReadMessageReturns(result1 int, result2 []byte, result3 error) {
	fake.readMessageMutex.Lock()
	defer fake.readMessageMutex.Unlock()
	fake.ReadMessageStub = nil
	fake.readMessageReturns = struct {
		result1 int
		result2 []byte
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeConn) ReadMessageReturnsOnCall(i int, result1 int, result2 []byte, result3 error) {
	fake.readMessageMutex.Lock()
	defer fake.readMessageMutex.Unlock()
	fake.ReadMessageStub = nil
	if fake.readMessageReturnsOnCall == nil {
		fake.readMessageReturnsOnCall = make(map[int]struct {
			result1 int
			result2 []byte
			result3 error
		})
	}
	fake.readMessageReturnsOnCall[i] = struct {
		result1 int
		result2 []byte
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeConn) RemoteAddr() net.Addr {
	fake.remoteAddrMutex.Lock()
	ret, specificReturn := fake.remoteAddrReturnsOnCall[len(fake.remoteAddrArgsForCall)]
	fake.remoteAddrArgsForCall = append(fake.remoteAddrArgsForCall, struct {
	}{})
	stub := fake.RemoteAddrStub
	fakeReturns := fake.remoteAddrReturns
	fake.recordInvocation("RemoteAddr", []interface{}{})
	fake.remoteAddrMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) RemoteAddrCallCount() int {
	fake.remoteAddrMutex.RLock()
	defer fake.remoteAddrMutex.RUnlock()
	return len(fake.remoteAddrArgsForCall)
}

func (fake *FakeConn) RemoteAddrCalls(stub func() net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = stub
}

func (fake *FakeConn) RemoteAddrReturns(result1 net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = nil
	fake.remoteAddrReturns = struct {
		result1 net.Addr
	}{result1}
}

func (fake *FakeConn) RemoteAddrReturnsOnCall(i int, result1 net.Addr) {
	fake.remoteAddrMutex.Lock()
	defer fake.remoteAddrMutex.Unlock()
	fake.RemoteAddrStub = nil
	if fake.remoteAddrReturnsOnCall == nil {
		fake.remoteAddrReturnsOnCall = make(map[int]struct {
			result1 net.Addr
		})
	}
	fake.remoteAddrReturnsOnCall[i] = struct {
		result1 net.Addr
	}{result1}
}

func (fake *FakeConn) SetCloseHandler(arg1 func(code int, text string) error) {
	fake.setCloseHandlerMutex.Lock()
	fake.setCloseHandlerArgsForCall = append(fake.setCloseHandlerArgsForCall, struct {
		arg1 func(code int, text string) error
	}{arg1})
	stub := fake.SetCloseHandlerStub
	fake.recordInvocation("SetCloseHandler", []interface{}{arg1})
	fake.setCloseHandlerMutex.Unlock()
	if stub != nil {
		fake.SetCloseHandlerStub(arg1)
	}
}

func (fake *FakeConn) SetCloseHandlerCallCount() int {
	fake.setCloseHandlerMutex.RLock()
	defer fake.setCloseHandlerMutex.RUnlock()
	return len(fake.setCloseHandlerArgsForCall)
}

func (fake *FakeConn) SetCloseHandlerCalls(stub func(func(code int, text string) error)) {
	fake.setCloseHandlerMutex.Lock()
	defer fake.setCloseHandlerMutex.Unlock()
	fake.SetCloseHandlerStub = stub
}

func (fake *FakeConn) SetCloseHandlerArgsForCall(i int) func(code int, text string) error {
	fake.setCloseHandlerMutex.RLock()
	defer fake.setCloseHandlerMutex.RUnlock()
	argsForCall := fake.setCloseHandlerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetCompressionLevel(arg1 int) error {
	fake.setCompressionLevelMutex.Lock()
	ret, specificReturn := fake.setCompressionLevelReturnsOnCall[len(fake.setCompressionLevelArgsForCall)]
	fake.setCompressionLevelArgsForCall = append(fake.setCompressionLevelArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.SetCompressionLevelStub
	fakeReturns := fake.setCompressionLevelReturns
	fake.recordInvocation("SetCompressionLevel", []interface{}{arg1})
	fake.setCompressionLevelMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) SetCompressionLevelCallCount() int {
	fake.setCompressionLevelMutex.RLock()
	defer fake.setCompressionLevelMutex.RUnlock()
	return len(fake.setCompressionLevelArgsForCall)
}

func (fake *FakeConn) SetCompressionLevelCalls(stub func(int) error) {
	fake.setCompressionLevelMutex.Lock()
	defer fake.setCompressionLevelMutex.Unlock()
	fake.SetCompressionLevelStub = stub
}

func (fake *FakeConn) SetCompressionLevelArgsForCall(i int) int {
	fake.setCompressionLevelMutex.RLock()
	defer fake.setCompressionLevelMutex.RUnlock()
	argsForCall := fake.setCompressionLevelArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetCompressionLevelReturns(result1 error) {
	fake.setCompressionLevelMutex.Lock()
	defer fake.setCompressionLevelMutex.Unlock()
	fake.SetCompressionLevelStub = nil
	fake.setCompressionLevelReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) SetCompressionLevelReturnsOnCall(i int, result1 error) {
	fake.setCompressionLevelMutex.Lock()
	defer fake.setCompressionLevelMutex.Unlock()
	fake.SetCompressionLevelStub = nil
	if fake.setCompressionLevelReturnsOnCall == nil {
		fake.setCompressionLevelReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setCompressionLevelReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) SetPingHandler(arg1 func(appData string) error) {
	fake.setPingHandlerMutex.Lock()
	fake.setPingHandlerArgsForCall = append(fake.setPingHandlerArgsForCall, struct {
		arg1 func(appData string) error
	}{arg1})
	stub := fake.SetPingHandlerStub
	fake.recordInvocation("SetPingHandler", []interface{}{arg1})
	fake.setPingHandlerMutex.Unlock()
	if stub != nil {
		fake.SetPingHandlerStub(arg1)
	}
}

func (fake *FakeConn) SetPingHandlerCallCount() int {
	fake.setPingHandlerMutex.RLock()
	defer fake.setPingHandlerMutex.RUnlock()
	return len(fake.setPingHandlerArgsForCall)
}

func (fake *FakeConn) SetPingHandlerCalls(stub func(func(appData string) error)) {
	fake.setPingHandlerMutex.Lock()
	defer fake.setPingHandlerMutex.Unlock()
	fake.SetPingHandlerStub = stub
}

func (fake *FakeConn) SetPingHandlerArgsForCall(i int) func(appData string) error {
	fake.setPingHandlerMutex.RLock()
	defer fake.setPingHandlerMutex.RUnlock()
	argsForCall := fake.setPingHandlerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetPongHandler(arg1 func(appData string) error) {
	fake.setPongHandlerMutex.Lock()
	fake.setPongHandlerArgsForCall = append(fake.setPongHandlerArgsForCall, struct {
		arg1 func(appData string) error
	}{arg1})
	stub := fake.SetPongHandlerStub
	fake.recordInvocation("SetPongHandler", []interface{}{arg1})
	fake.setPongHandlerMutex.Unlock()
	if stub != nil {
		fake.SetPongHandlerStub(arg1)
	}
}

func (fake *FakeConn) SetPongHandlerCallCount() int {
	fake.setPongHandlerMutex.RLock()
	defer fake.setPongHandlerMutex.RUnlock()
	return len(fake.setPongHandlerArgsForCall)
}

func (fake *FakeConn) SetPongHandlerCalls(stub func(func(appData string) error)) {
	fake.setPongHandlerMutex.Lock()
	defer fake.setPongHandlerMutex.Unlock()
	fake.SetPongHandlerStub = stub
}

func (fake *FakeConn) SetPongHandlerArgsForCall(i int) func(appData string) error {
	fake.setPongHandlerMutex.RLock()
	defer fake.setPongHandlerMutex.RUnlock()
	argsForCall := fake.setPongHandlerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetReadDeadline(arg1 time.Time) error {
	fake.setReadDeadlineMutex.Lock()
	ret, specificReturn := fake.setReadDeadlineReturnsOnCall[len(fake.setReadDeadlineArgsForCall)]
	fake.setReadDeadlineArgsForCall = append(fake.setReadDeadlineArgsForCall, struct {
		arg1 time.Time
	}{arg1})
	stub := fake.SetReadDeadlineStub
	fakeReturns := fake.setReadDeadlineReturns
	fake.recordInvocation("SetReadDeadline", []interface{}{arg1})
	fake.setReadDeadlineMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) SetReadDeadlineCallCount() int {
	fake.setReadDeadlineMutex.RLock()
	defer fake.setReadDeadlineMutex.RUnlock()
	return len(fake.setReadDeadlineArgsForCall)
}

func (fake *FakeConn) SetReadDeadlineCalls(stub func(time.Time) error) {
	fake.setReadDeadlineMutex.Lock()
	defer fake.setReadDeadlineMutex.Unlock()
	fake.SetReadDeadlineStub = stub
}

func (fake *FakeConn) SetReadDeadlineArgsForCall(i int) time.Time {
	fake.setReadDeadlineMutex.RLock()
	defer fake.setReadDeadlineMutex.RUnlock()
	argsForCall := fake.setReadDeadlineArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetReadDeadlineReturns(result1 error) {
	fake.setReadDeadlineMutex.Lock()
	defer fake.setReadDeadlineMutex.Unlock()
	fake.SetReadDeadlineStub = nil
	fake.setReadDeadlineReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) SetReadDeadlineReturnsOnCall(i int, result1 error) {
	fake.setReadDeadlineMutex.Lock()
	defer fake.setReadDeadlineMutex.Unlock()
	fake.SetReadDeadlineStub = nil
	if fake.setReadDeadlineReturnsOnCall == nil {
		fake.setReadDeadlineReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setReadDeadlineReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) SetReadLimit(arg1 int64) {
	fake.setReadLimitMutex.Lock()
	fake.setReadLimitArgsForCall = append(fake.setReadLimitArgsForCall, struct {
		arg1 int64
	}{arg1})
	stub := fake.SetReadLimitStub
	fake.recordInvocation("SetReadLimit", []interface{}{arg1})
	fake.setReadLimitMutex.Unlock()
	if stub != nil {
		fake.SetReadLimitStub(arg1)
	}
}

func (fake *FakeConn) SetReadLimitCallCount() int {
	fake.setReadLimitMutex.RLock()
	defer fake.setReadLimitMutex.RUnlock()
	return len(fake.setReadLimitArgsForCall)
}

func (fake *FakeConn) SetReadLimitCalls(stub func(int64)) {
	fake.setReadLimitMutex.Lock()
	defer fake.setReadLimitMutex.Unlock()
	fake.SetReadLimitStub = stub
}

func (fake *FakeConn) SetReadLimitArgsForCall(i int) int64 {
	fake.setReadLimitMutex.RLock()
	defer fake.setReadLimitMutex.RUnlock()
	argsForCall := fake.setReadLimitArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetWriteDeadline(arg1 time.Time) error {
	fake.setWriteDeadlineMutex.Lock()
	ret, specificReturn := fake.setWriteDeadlineReturnsOnCall[len(fake.setWriteDeadlineArgsForCall)]
	fake.setWriteDeadlineArgsForCall = append(fake.setWriteDeadlineArgsForCall, struct {
		arg1 time.Time
	}{arg1})
	stub := fake.SetWriteDeadlineStub
	fakeReturns := fake.setWriteDeadlineReturns
	fake.recordInvocation("SetWriteDeadline", []interface{}{arg1})
	fake.setWriteDeadlineMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) SetWriteDeadlineCallCount() int {
	fake.setWriteDeadlineMutex.RLock()
	defer fake.setWriteDeadlineMutex.RUnlock()
	return len(fake.setWriteDeadlineArgsForCall)
}

func (fake *FakeConn) SetWriteDeadlineCalls(stub func(time.Time) error) {
	fake.setWriteDeadlineMutex.Lock()
	defer fake.setWriteDeadlineMutex.Unlock()
	fake.SetWriteDeadlineStub = stub
}

func (fake *FakeConn) SetWriteDeadlineArgsForCall(i int) time.Time {
	fake.setWriteDeadlineMutex.RLock()
	defer fake.setWriteDeadlineMutex.RUnlock()
	argsForCall := fake.setWriteDeadlineArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) SetWriteDeadlineReturns(result1 error) {
	fake.setWriteDeadlineMutex.Lock()
	defer fake.setWriteDeadlineMutex.Unlock()
	fake.SetWriteDeadlineStub = nil
	fake.setWriteDeadlineReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) SetWriteDeadlineReturnsOnCall(i int, result1 error) {
	fake.setWriteDeadlineMutex.Lock()
	defer fake.setWriteDeadlineMutex.Unlock()
	fake.SetWriteDeadlineStub = nil
	if fake.setWriteDeadlineReturnsOnCall == nil {
		fake.setWriteDeadlineReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setWriteDeadlineReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) Subprotocol() string {
	fake.subprotocolMutex.Lock()
	ret, specificReturn := fake.subprotocolReturnsOnCall[len(fake.subprotocolArgsForCall)]
	fake.subprotocolArgsForCall = append(fake.subprotocolArgsForCall, struct {
	}{})
	stub := fake.SubprotocolStub
	fakeReturns := fake.subprotocolReturns
	fake.recordInvocation("Subprotocol", []interface{}{})
	fake.subprotocolMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) SubprotocolCallCount() int {
	fake.subprotocolMutex.RLock()
	defer fake.subprotocolMutex.RUnlock()
	return len(fake.subprotocolArgsForCall)
}

func (fake *FakeConn) SubprotocolCalls(stub func() string) {
	fake.subprotocolMutex.Lock()
	defer fake.subprotocolMutex.Unlock()
	fake.SubprotocolStub = stub
}

func (fake *FakeConn) SubprotocolReturns(result1 string) {
	fake.subprotocolMutex.Lock()
	defer fake.subprotocolMutex.Unlock()
	fake.SubprotocolStub = nil
	fake.subprotocolReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConn) SubprotocolReturnsOnCall(i int, result1 string) {
	fake.subprotocolMutex.Lock()
	defer fake.subprotocolMutex.Unlock()
	fake.SubprotocolStub = nil
	if fake.subprotocolReturnsOnCall == nil {
		fake.subprotocolReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.subprotocolReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConn) UnderlyingConn() net.Conn {
	fake.underlyingConnMutex.Lock()
	ret, specificReturn := fake.underlyingConnReturnsOnCall[len(fake.underlyingConnArgsForCall)]
	fake.underlyingConnArgsForCall = append(fake.underlyingConnArgsForCall, struct {
	}{})
	stub := fake.UnderlyingConnStub
	fakeReturns := fake.underlyingConnReturns
	fake.recordInvocation("UnderlyingConn", []interface{}{})
	fake.underlyingConnMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) UnderlyingConnCallCount() int {
	fake.underlyingConnMutex.RLock()
	defer fake.underlyingConnMutex.RUnlock()
	return len(fake.underlyingConnArgsForCall)
}

func (fake *FakeConn) UnderlyingConnCalls(stub func() net.Conn) {
	fake.underlyingConnMutex.Lock()
	defer fake.underlyingConnMutex.Unlock()
	fake.UnderlyingConnStub = stub
}

func (fake *FakeConn) UnderlyingConnReturns(result1 net.Conn) {
	fake.underlyingConnMutex.Lock()
	defer fake.underlyingConnMutex.Unlock()
	fake.UnderlyingConnStub = nil
	fake.underlyingConnReturns = struct {
		result1 net.Conn
	}{result1}
}

func (fake *FakeConn) UnderlyingConnReturnsOnCall(i int, result1 net.Conn) {
	fake.underlyingConnMutex.Lock()
	defer fake.underlyingConnMutex.Unlock()
	fake.UnderlyingConnStub = nil
	if fake.underlyingConnReturnsOnCall == nil {
		fake.underlyingConnReturnsOnCall = make(map[int]struct {
			result1 net.Conn
		})
	}
	fake.underlyingConnReturnsOnCall[i] = struct {
		result1 net.Conn
	}{result1}
}

func (fake *FakeConn) WriteControl(arg1 int, arg2 []byte, arg3 time.Time) error {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.writeControlMutex.Lock()
	ret, specificReturn := fake.writeControlReturnsOnCall[len(fake.writeControlArgsForCall)]
	fake.writeControlArgsForCall = append(fake.writeControlArgsForCall, struct {
		arg1 int
		arg2 []byte
		arg3 time.Time
	}{arg1, arg2Copy, arg3})
	stub := fake.WriteControlStub
	fakeReturns := fake.writeControlReturns
	fake.recordInvocation("WriteControl", []interface{}{arg1, arg2Copy, arg3})
	fake.writeControlMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) WriteControlCallCount() int {
	fake.writeControlMutex.RLock()
	defer fake.writeControlMutex.RUnlock()
	return len(fake.writeControlArgsForCall)
}

func (fake *FakeConn) WriteControlCalls(stub func(int, []byte, time.Time) error) {
	fake.writeControlMutex.Lock()
	defer fake.writeControlMutex.Unlock()
	fake.WriteControlStub = stub
}

func (fake *FakeConn) WriteControlArgsForCall(i int) (int, []byte, time.Time) {
	fake.writeControlMutex.RLock()
	defer fake.writeControlMutex.RUnlock()
	argsForCall := fake.writeControlArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeConn) WriteControlReturns(result1 error) {
	fake.writeControlMutex.Lock()
	defer fake.writeControlMutex.Unlock()
	fake.WriteControlStub = nil
	fake.writeControlReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) WriteControlReturnsOnCall(i int, result1 error) {
	fake.writeControlMutex.Lock()
	defer fake.writeControlMutex.Unlock()
	fake.WriteControlStub = nil
	if fake.writeControlReturnsOnCall == nil {
		fake.writeControlReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writeControlReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) WriteMessage(arg1 int, arg2 []byte) error {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.writeMessageMutex.Lock()
	ret, specificReturn := fake.writeMessageReturnsOnCall[len(fake.writeMessageArgsForCall)]
	fake.writeMessageArgsForCall = append(fake.writeMessageArgsForCall, struct {
		arg1 int
		arg2 []byte
	}{arg1, arg2Copy})
	stub := fake.WriteMessageStub
	fakeReturns := fake.writeMessageReturns
	fake.recordInvocation("WriteMessage", []interface{}{arg1, arg2Copy})
	fake.writeMessageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) WriteMessageCallCount() int {
	fake.writeMessageMutex.RLock()
	defer fake.writeMessageMutex.RUnlock()
	return len(fake.writeMessageArgsForCall)
}

func (fake *FakeConn) WriteMessageCalls(stub func(int, []byte) error) {
	fake.writeMessageMutex.Lock()
	defer fake.writeMessageMutex.Unlock()
	fake.WriteMessageStub = stub
}

func (fake *FakeConn) WriteMessageArgsForCall(i int) (int, []byte) {
	fake.writeMessageMutex.RLock()
	defer fake.writeMessageMutex.RUnlock()
	argsForCall := fake.writeMessageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeConn) WriteMessageReturns(result1 error) {
	fake.writeMessageMutex.Lock()
	defer fake.writeMessageMutex.Unlock()
	fake.WriteMessageStub = nil
	fake.writeMessageReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) WriteMessageReturnsOnCall(i int, result1 error) {
	fake.writeMessageMutex.Lock()
	defer fake.writeMessageMutex.Unlock()
	fake.WriteMessageStub = nil
	if fake.writeMessageReturnsOnCall == nil {
		fake.writeMessageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writeMessageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) WritePreparedMessage(arg1 *websocket.PreparedMessage) error {
	fake.writePreparedMessageMutex.Lock()
	ret, specificReturn := fake.writePreparedMessageReturnsOnCall[len(fake.writePreparedMessageArgsForCall)]
	fake.writePreparedMessageArgsForCall = append(fake.writePreparedMessageArgsForCall, struct {
		arg1 *websocket.PreparedMessage
	}{arg1})
	stub := fake.WritePreparedMessageStub
	fakeReturns := fake.writePreparedMessageReturns
	fake.recordInvocation("WritePreparedMessage", []interface{}{arg1})
	fake.writePreparedMessageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConn) WritePreparedMessageCallCount() int {
	fake.writePreparedMessageMutex.RLock()
	defer fake.writePreparedMessageMutex.RUnlock()
	return len(fake.writePreparedMessageArgsForCall)
}

func (fake *FakeConn) WritePreparedMessageCalls(stub func(*websocket.PreparedMessage) error) {
	fake.writePreparedMessageMutex.Lock()
	defer fake.writePreparedMessageMutex.Unlock()
	fake.WritePreparedMessageStub = stub
}

func (fake *FakeConn) WritePreparedMessageArgsForCall(i int) *websocket.PreparedMessage {
	fake.writePreparedMessageMutex.RLock()
	defer fake.writePreparedMessageMutex.RUnlock()
	argsForCall := fake.writePreparedMessageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConn) WritePreparedMessageReturns(result1 error) {
	fake.writePreparedMessageMutex.Lock()
	defer fake.writePreparedMessageMutex.Unlock()
	fake.WritePreparedMessageStub = nil
	fake.writePreparedMessageReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) WritePreparedMessageReturnsOnCall(i int, result1 error) {
	fake.writePreparedMessageMutex.Lock()
	defer fake.writePreparedMessageMutex.Unlock()
	fake.WritePreparedMessageStub = nil
	if fake.writePreparedMessageReturnsOnCall == nil {
		fake.writePreparedMessageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writePreparedMessageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConn) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	fake.closeHandlerMutex.RLock()
	defer fake.closeHandlerMutex.RUnlock()
	fake.enableWriteCompressionMutex.RLock()
	defer fake.enableWriteCompressionMutex.RUnlock()
	fake.localAddrMutex.RLock()
	defer fake.localAddrMutex.RUnlock()
	fake.nextReaderMutex.RLock()
	defer fake.nextReaderMutex.RUnlock()
	fake.nextWriterMutex.RLock()
	defer fake.nextWriterMutex.RUnlock()
	fake.pingHandlerMutex.RLock()
	defer fake.pingHandlerMutex.RUnlock()
	fake.pongHandlerMutex.RLock()
	defer fake.pongHandlerMutex.RUnlock()
	fake.readMessageMutex.RLock()
	defer fake.readMessageMutex.RUnlock()
	fake.remoteAddrMutex.RLock()
	defer fake.remoteAddrMutex.RUnlock()
	fake.setCloseHandlerMutex.RLock()
	defer fake.setCloseHandlerMutex.RUnlock()
	fake.setCompressionLevelMutex.RLock()
	defer fake.setCompressionLevelMutex.RUnlock()
	fake.setPingHandlerMutex.RLock()
	defer fake.setPingHandlerMutex.RUnlock()
	fake.setPongHandlerMutex.RLock()
	defer fake.setPongHandlerMutex.RUnlock()
	fake.setReadDeadlineMutex.RLock()
	defer fake.setReadDeadlineMutex.RUnlock()
	fake.setReadLimitMutex.RLock()
	defer fake.setReadLimitMutex.RUnlock()
	fake.setWriteDeadlineMutex.RLock()
	defer fake.setWriteDeadlineMutex.RUnlock()
	fake.subprotocolMutex.RLock()
	defer fake.subprotocolMutex.RUnlock()
	fake.underlyingConnMutex.RLock()
	defer fake.underlyingConnMutex.RUnlock()
	fake.writeControlMutex.RLock()
	defer fake.writeControlMutex.RUnlock()
	fake.writeMessageMutex.RLock()
	defer fake.writeMessageMutex.RUnlock()
	fake.writePreparedMessageMutex.RLock()
	defer fake.writePreparedMessageMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeConn) 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 _ ext.Conn = new(FakeConn)