Delete conn_test.go

external/github.com/gorilla/websocket/conn_test.go

@@ -1,696 +0,0 @@
-// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package websocket
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"reflect"
-	"sync"
-	"testing"
-	"testing/iotest"
-	"time"
-)
-
-var _ net.Error = errWriteTimeout
-
-type fakeNetConn struct {
-	io.Reader
-	io.Writer
-}
-
-func (c fakeNetConn) Close() error                       { return nil }
-func (c fakeNetConn) LocalAddr() net.Addr                { return localAddr }
-func (c fakeNetConn) RemoteAddr() net.Addr               { return remoteAddr }
-func (c fakeNetConn) SetDeadline(t time.Time) error      { return nil }
-func (c fakeNetConn) SetReadDeadline(t time.Time) error  { return nil }
-func (c fakeNetConn) SetWriteDeadline(t time.Time) error { return nil }
-
-type fakeAddr int
-
-var (
-	localAddr  = fakeAddr(1)
-	remoteAddr = fakeAddr(2)
-)
-
-func (a fakeAddr) Network() string {
-	return "net"
-}
-
-func (a fakeAddr) String() string {
-	return "str"
-}
-
-// newTestConn creates a connnection backed by a fake network connection using
-// default values for buffering.
-func newTestConn(r io.Reader, w io.Writer, isServer bool) *Conn {
-	return newConn(fakeNetConn{Reader: r, Writer: w}, isServer, 1024, 1024, nil, nil, nil)
-}
-
-func TestFraming(t *testing.T) {
-	frameSizes := []int{
-		0, 1, 2, 124, 125, 126, 127, 128, 129, 65534, 65535,
-		// 65536, 65537
-	}
-	var readChunkers = []struct {
-		name string
-		f    func(io.Reader) io.Reader
-	}{
-		{"half", iotest.HalfReader},
-		{"one", iotest.OneByteReader},
-		{"asis", func(r io.Reader) io.Reader { return r }},
-	}
-	writeBuf := make([]byte, 65537)
-	for i := range writeBuf {
-		writeBuf[i] = byte(i)
-	}
-	var writers = []struct {
-		name string
-		f    func(w io.Writer, n int) (int, error)
-	}{
-		{"iocopy", func(w io.Writer, n int) (int, error) {
-			nn, err := io.Copy(w, bytes.NewReader(writeBuf[:n]))
-			return int(nn), err
-		}},
-		{"write", func(w io.Writer, n int) (int, error) {
-			return w.Write(writeBuf[:n])
-		}},
-		{"string", func(w io.Writer, n int) (int, error) {
-			return io.WriteString(w, string(writeBuf[:n]))
-		}},
-	}
-
-	for _, compress := range []bool{false, true} {
-		for _, isServer := range []bool{true, false} {
-			for _, chunker := range readChunkers {
-
-				var connBuf bytes.Buffer
-				wc := newTestConn(nil, &connBuf, isServer)
-				rc := newTestConn(chunker.f(&connBuf), nil, !isServer)
-				//if compress {
-				//	wc.newCompressionWriter = compressNoContextTakeover
-				//	rc.newDecompressionReader = decompressNoContextTakeover
-				//}
-				for _, n := range frameSizes {
-					for _, writer := range writers {
-						name := fmt.Sprintf("z:%v, s:%v, r:%s, n:%d w:%s", compress, isServer, chunker.name, n, writer.name)
-
-						w, err := wc.NextWriter(TextMessage)
-						if err != nil {
-							t.Errorf("%s: wc.NextWriter() returned %v", name, err)
-							continue
-						}
-						nn, err := writer.f(w, n)
-						if err != nil || nn != n {
-							t.Errorf("%s: w.Write(writeBuf[:n]) returned %d, %v", name, nn, err)
-							continue
-						}
-						err = w.Close()
-						if err != nil {
-							t.Errorf("%s: w.Close() returned %v", name, err)
-							continue
-						}
-
-						opCode, r, err := rc.NextReader()
-						if err != nil || opCode != TextMessage {
-							t.Errorf("%s: NextReader() returned %d, r, %v", name, opCode, err)
-							continue
-						}
-
-						t.Logf("frame size: %d", n)
-						rbuf, err := ioutil.ReadAll(r)
-						if err != nil {
-							t.Errorf("%s: ReadFull() returned rbuf, %v", name, err)
-							continue
-						}
-
-						if len(rbuf) != n {
-							t.Errorf("%s: len(rbuf) is %d, want %d", name, len(rbuf), n)
-							continue
-						}
-
-						for i, b := range rbuf {
-							if byte(i) != b {
-								t.Errorf("%s: bad byte at offset %d", name, i)
-								break
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func TestControl(t *testing.T) {
-	const message = "this is a ping/pong messsage"
-	for _, isServer := range []bool{true, false} {
-		for _, isWriteControl := range []bool{true, false} {
-			name := fmt.Sprintf("s:%v, wc:%v", isServer, isWriteControl)
-			var connBuf bytes.Buffer
-			wc := newTestConn(nil, &connBuf, isServer)
-			rc := newTestConn(&connBuf, nil, !isServer)
-			if isWriteControl {
-				wc.WriteControl(PongMessage, []byte(message), time.Now().Add(time.Second))
-			} else {
-				w, err := wc.NextWriter(PongMessage)
-				if err != nil {
-					t.Errorf("%s: wc.NextWriter() returned %v", name, err)
-					continue
-				}
-				if _, err := w.Write([]byte(message)); err != nil {
-					t.Errorf("%s: w.Write() returned %v", name, err)
-					continue
-				}
-				if err := w.Close(); err != nil {
-					t.Errorf("%s: w.Close() returned %v", name, err)
-					continue
-				}
-				var actualMessage string
-				rc.SetPongHandler(func(s string) error { actualMessage = s; return nil })
-				rc.NextReader()
-				if actualMessage != message {
-					t.Errorf("%s: pong=%q, want %q", name, actualMessage, message)
-					continue
-				}
-			}
-		}
-	}
-}
-
-// simpleBufferPool is an implementation of BufferPool for TestWriteBufferPool.
-type simpleBufferPool struct {
-	v interface{}
-}
-
-func (p *simpleBufferPool) Get() interface{} {
-	v := p.v
-	p.v = nil
-	return v
-}
-
-func (p *simpleBufferPool) Put(v interface{}) {
-	p.v = v
-}
-
-func TestWriteBufferPool(t *testing.T) {
-	const message = "Now is the time for all good people to come to the aid of the party."
-
-	var buf bytes.Buffer
-	var pool simpleBufferPool
-	rc := newTestConn(&buf, nil, false)
-
-	// Specify writeBufferSize smaller than message size to ensure that pooling
-	// works with fragmented messages.
-	wc := newConn(fakeNetConn{Writer: &buf}, true, 1024, len(message)-1, &pool, nil, nil)
-
-	if wc.writeBuf != nil {
-		t.Fatal("writeBuf not nil after create")
-	}
-
-	// Part 1: test NextWriter/Write/Close
-
-	w, err := wc.NextWriter(TextMessage)
-	if err != nil {
-		t.Fatalf("wc.NextWriter() returned %v", err)
-	}
-
-	if wc.writeBuf == nil {
-		t.Fatal("writeBuf is nil after NextWriter")
-	}
-
-	writeBufAddr := &wc.writeBuf[0]
-
-	if _, err := io.WriteString(w, message); err != nil {
-		t.Fatalf("io.WriteString(w, message) returned %v", err)
-	}
-
-	if err := w.Close(); err != nil {
-		t.Fatalf("w.Close() returned %v", err)
-	}
-
-	if wc.writeBuf != nil {
-		t.Fatal("writeBuf not nil after w.Close()")
-	}
-
-	if wpd, ok := pool.v.(writePoolData); !ok || len(wpd.buf) == 0 || &wpd.buf[0] != writeBufAddr {
-		t.Fatal("writeBuf not returned to pool")
-	}
-
-	opCode, p, err := rc.ReadMessage()
-	if opCode != TextMessage || err != nil {
-		t.Fatalf("ReadMessage() returned %d, p, %v", opCode, err)
-	}
-
-	if s := string(p); s != message {
-		t.Fatalf("message is %s, want %s", s, message)
-	}
-
-	// Part 2: Test WriteMessage.
-
-	if err := wc.WriteMessage(TextMessage, []byte(message)); err != nil {
-		t.Fatalf("wc.WriteMessage() returned %v", err)
-	}
-
-	if wc.writeBuf != nil {
-		t.Fatal("writeBuf not nil after wc.WriteMessage()")
-	}
-
-	if wpd, ok := pool.v.(writePoolData); !ok || len(wpd.buf) == 0 || &wpd.buf[0] != writeBufAddr {
-		t.Fatal("writeBuf not returned to pool after WriteMessage")
-	}
-
-	opCode, p, err = rc.ReadMessage()
-	if opCode != TextMessage || err != nil {
-		t.Fatalf("ReadMessage() returned %d, p, %v", opCode, err)
-	}
-
-	if s := string(p); s != message {
-		t.Fatalf("message is %s, want %s", s, message)
-	}
-}
-
-// TestWriteBufferPoolSync ensures that *sync.Pool works as a buffer pool.
-func TestWriteBufferPoolSync(t *testing.T) {
-	var buf bytes.Buffer
-	var pool sync.Pool
-	wc := newConn(fakeNetConn{Writer: &buf}, true, 1024, 1024, &pool, nil, nil)
-	rc := newTestConn(&buf, nil, false)
-
-	const message = "Hello World!"
-	for i := 0; i < 3; i++ {
-		if err := wc.WriteMessage(TextMessage, []byte(message)); err != nil {
-			t.Fatalf("wc.WriteMessage() returned %v", err)
-		}
-		opCode, p, err := rc.ReadMessage()
-		if opCode != TextMessage || err != nil {
-			t.Fatalf("ReadMessage() returned %d, p, %v", opCode, err)
-		}
-		if s := string(p); s != message {
-			t.Fatalf("message is %s, want %s", s, message)
-		}
-	}
-}
-
-// errorWriter is an io.Writer than returns an error on all writes.
-type errorWriter struct{}
-
-func (ew errorWriter) Write(p []byte) (int, error) { return 0, errors.New("error") }
-
-// TestWriteBufferPoolError ensures that buffer is returned to pool after error
-// on write.
-func TestWriteBufferPoolError(t *testing.T) {
-
-	// Part 1: Test NextWriter/Write/Close
-
-	var pool simpleBufferPool
-	wc := newConn(fakeNetConn{Writer: errorWriter{}}, true, 1024, 1024, &pool, nil, nil)
-
-	w, err := wc.NextWriter(TextMessage)
-	if err != nil {
-		t.Fatalf("wc.NextWriter() returned %v", err)
-	}
-
-	if wc.writeBuf == nil {
-		t.Fatal("writeBuf is nil after NextWriter")
-	}
-
-	writeBufAddr := &wc.writeBuf[0]
-
-	if _, err := io.WriteString(w, "Hello"); err != nil {
-		t.Fatalf("io.WriteString(w, message) returned %v", err)
-	}
-
-	if err := w.Close(); err == nil {
-		t.Fatalf("w.Close() did not return error")
-	}
-
-	if wpd, ok := pool.v.(writePoolData); !ok || len(wpd.buf) == 0 || &wpd.buf[0] != writeBufAddr {
-		t.Fatal("writeBuf not returned to pool")
-	}
-
-	// Part 2: Test WriteMessage
-
-	wc = newConn(fakeNetConn{Writer: errorWriter{}}, true, 1024, 1024, &pool, nil, nil)
-
-	if err := wc.WriteMessage(TextMessage, []byte("Hello")); err == nil {
-		t.Fatalf("wc.WriteMessage did not return error")
-	}
-
-	if wpd, ok := pool.v.(writePoolData); !ok || len(wpd.buf) == 0 || &wpd.buf[0] != writeBufAddr {
-		t.Fatal("writeBuf not returned to pool")
-	}
-}
-
-func TestCloseFrameBeforeFinalMessageFrame(t *testing.T) {
-	const bufSize = 512
-
-	expectedErr := &CloseError{Code: CloseNormalClosure, Text: "hello"}
-
-	var b1, b2 bytes.Buffer
-	wc := newConn(&fakeNetConn{Reader: nil, Writer: &b1}, false, 1024, bufSize, nil, nil, nil)
-	rc := newTestConn(&b1, &b2, true)
-
-	w, _ := wc.NextWriter(BinaryMessage)
-	w.Write(make([]byte, bufSize+bufSize/2))
-	wc.WriteControl(CloseMessage, FormatCloseMessage(expectedErr.Code, expectedErr.Text), time.Now().Add(10*time.Second))
-	w.Close()
-
-	op, r, err := rc.NextReader()
-	if op != BinaryMessage || err != nil {
-		t.Fatalf("NextReader() returned %d, %v", op, err)
-	}
-	_, err = io.Copy(ioutil.Discard, r)
-	if !reflect.DeepEqual(err, expectedErr) {
-		t.Fatalf("io.Copy() returned %v, want %v", err, expectedErr)
-	}
-	_, _, err = rc.NextReader()
-	if !reflect.DeepEqual(err, expectedErr) {
-		t.Fatalf("NextReader() returned %v, want %v", err, expectedErr)
-	}
-}
-
-func TestEOFWithinFrame(t *testing.T) {
-	const bufSize = 64
-
-	for n := 0; ; n++ {
-		var b bytes.Buffer
-		wc := newTestConn(nil, &b, false)
-		rc := newTestConn(&b, nil, true)
-
-		w, _ := wc.NextWriter(BinaryMessage)
-		w.Write(make([]byte, bufSize))
-		w.Close()
-
-		if n >= b.Len() {
-			break
-		}
-		b.Truncate(n)
-
-		op, r, err := rc.NextReader()
-		if err == errUnexpectedEOF {
-			continue
-		}
-		if op != BinaryMessage || err != nil {
-			t.Fatalf("%d: NextReader() returned %d, %v", n, op, err)
-		}
-		_, err = io.Copy(ioutil.Discard, r)
-		if err != errUnexpectedEOF {
-			t.Fatalf("%d: io.Copy() returned %v, want %v", n, err, errUnexpectedEOF)
-		}
-		_, _, err = rc.NextReader()
-		if err != errUnexpectedEOF {
-			t.Fatalf("%d: NextReader() returned %v, want %v", n, err, errUnexpectedEOF)
-		}
-	}
-}
-
-func TestEOFBeforeFinalFrame(t *testing.T) {
-	const bufSize = 512
-
-	var b1, b2 bytes.Buffer
-	wc := newConn(&fakeNetConn{Writer: &b1}, false, 1024, bufSize, nil, nil, nil)
-	rc := newTestConn(&b1, &b2, true)
-
-	w, _ := wc.NextWriter(BinaryMessage)
-	w.Write(make([]byte, bufSize+bufSize/2))
-
-	op, r, err := rc.NextReader()
-	if op != BinaryMessage || err != nil {
-		t.Fatalf("NextReader() returned %d, %v", op, err)
-	}
-	_, err = io.Copy(ioutil.Discard, r)
-	if err != errUnexpectedEOF {
-		t.Fatalf("io.Copy() returned %v, want %v", err, errUnexpectedEOF)
-	}
-	_, _, err = rc.NextReader()
-	if err != errUnexpectedEOF {
-		t.Fatalf("NextReader() returned %v, want %v", err, errUnexpectedEOF)
-	}
-}
-
-func TestWriteAfterMessageWriterClose(t *testing.T) {
-	wc := newTestConn(nil, &bytes.Buffer{}, false)
-	w, _ := wc.NextWriter(BinaryMessage)
-	io.WriteString(w, "hello")
-	if err := w.Close(); err != nil {
-		t.Fatalf("unxpected error closing message writer, %v", err)
-	}
-
-	if _, err := io.WriteString(w, "world"); err == nil {
-		t.Fatalf("no error writing after close")
-	}
-
-	w, _ = wc.NextWriter(BinaryMessage)
-	io.WriteString(w, "hello")
-
-	// close w by getting next writer
-	_, err := wc.NextWriter(BinaryMessage)
-	if err != nil {
-		t.Fatalf("unexpected error getting next writer, %v", err)
-	}
-
-	if _, err := io.WriteString(w, "world"); err == nil {
-		t.Fatalf("no error writing after close")
-	}
-}
-
-func TestReadLimit(t *testing.T) {
-	t.Run("Test ReadLimit is enforced", func(t *testing.T) {
-		const readLimit = 512
-		message := make([]byte, readLimit+1)
-
-		var b1, b2 bytes.Buffer
-		wc := newConn(&fakeNetConn{Writer: &b1}, false, 1024, readLimit-2, nil, nil, nil)
-		rc := newTestConn(&b1, &b2, true)
-		rc.SetReadLimit(readLimit)
-
-		// Send message at the limit with interleaved pong.
-		w, _ := wc.NextWriter(BinaryMessage)
-		w.Write(message[:readLimit-1])
-		wc.WriteControl(PongMessage, []byte("this is a pong"), time.Now().Add(10*time.Second))
-		w.Write(message[:1])
-		w.Close()
-
-		// Send message larger than the limit.
-		wc.WriteMessage(BinaryMessage, message[:readLimit+1])
-
-		op, _, err := rc.NextReader()
-		if op != BinaryMessage || err != nil {
-			t.Fatalf("1: NextReader() returned %d, %v", op, err)
-		}
-		op, r, err := rc.NextReader()
-		if op != BinaryMessage || err != nil {
-			t.Fatalf("2: NextReader() returned %d, %v", op, err)
-		}
-		_, err = io.Copy(ioutil.Discard, r)
-		if err != ErrReadLimit {
-			t.Fatalf("io.Copy() returned %v", err)
-		}
-	})
-
-	t.Run("Test that ReadLimit cannot be overflowed", func(t *testing.T) {
-		const readLimit = 1
-
-		var b1, b2 bytes.Buffer
-		rc := newTestConn(&b1, &b2, true)
-		rc.SetReadLimit(readLimit)
-
-		// First, send a non-final binary message
-		b1.Write([]byte("\x02\x81"))
-
-		// Mask key
-		b1.Write([]byte("\x00\x00\x00\x00"))
-
-		// First payload
-		b1.Write([]byte("A"))
-
-		// Next, send a negative-length, non-final continuation frame
-		b1.Write([]byte("\x00\xFF\x80\x00\x00\x00\x00\x00\x00\x00"))
-
-		// Mask key
-		b1.Write([]byte("\x00\x00\x00\x00"))
-
-		// Next, send a too long, final continuation frame
-		b1.Write([]byte("\x80\xFF\x00\x00\x00\x00\x00\x00\x00\x05"))
-
-		// Mask key
-		b1.Write([]byte("\x00\x00\x00\x00"))
-
-		// Too-long payload
-		b1.Write([]byte("BCDEF"))
-
-		op, r, err := rc.NextReader()
-		if op != BinaryMessage || err != nil {
-			t.Fatalf("1: NextReader() returned %d, %v", op, err)
-		}
-
-		var buf [10]byte
-		var read int
-		n, err := r.Read(buf[:])
-		if err != nil && err != ErrReadLimit {
-			t.Fatalf("unexpected error testing read limit: %v", err)
-		}
-		read += n
-
-		n, err = r.Read(buf[:])
-		if err != nil && err != ErrReadLimit {
-			t.Fatalf("unexpected error testing read limit: %v", err)
-		}
-		read += n
-
-		if err == nil && read > readLimit {
-			t.Fatalf("read limit exceeded: limit %d, read %d", readLimit, read)
-		}
-	})
-}
-
-func TestAddrs(t *testing.T) {
-	c := newTestConn(nil, nil, true)
-	if c.LocalAddr() != localAddr {
-		t.Errorf("LocalAddr = %v, want %v", c.LocalAddr(), localAddr)
-	}
-	if c.RemoteAddr() != remoteAddr {
-		t.Errorf("RemoteAddr = %v, want %v", c.RemoteAddr(), remoteAddr)
-	}
-}
-
-func TestUnderlyingConn(t *testing.T) {
-	var b1, b2 bytes.Buffer
-	fc := fakeNetConn{Reader: &b1, Writer: &b2}
-	c := newConn(fc, true, 1024, 1024, nil, nil, nil)
-	ul := c.UnderlyingConn()
-	if ul != fc {
-		t.Fatalf("Underlying conn is not what it should be.")
-	}
-}
-
-func TestBufioReadBytes(t *testing.T) {
-	// Test calling bufio.ReadBytes for value longer than read buffer size.
-
-	m := make([]byte, 512)
-	m[len(m)-1] = '\n'
-
-	var b1, b2 bytes.Buffer
-	wc := newConn(fakeNetConn{Writer: &b1}, false, len(m)+64, len(m)+64, nil, nil, nil)
-	rc := newConn(fakeNetConn{Reader: &b1, Writer: &b2}, true, len(m)-64, len(m)-64, nil, nil, nil)
-
-	w, _ := wc.NextWriter(BinaryMessage)
-	w.Write(m)
-	w.Close()
-
-	op, r, err := rc.NextReader()
-	if op != BinaryMessage || err != nil {
-		t.Fatalf("NextReader() returned %d, %v", op, err)
-	}
-
-	br := bufio.NewReader(r)
-	p, err := br.ReadBytes('\n')
-	if err != nil {
-		t.Fatalf("ReadBytes() returned %v", err)
-	}
-	if len(p) != len(m) {
-		t.Fatalf("read returned %d bytes, want %d bytes", len(p), len(m))
-	}
-}
-
-var closeErrorTests = []struct {
-	err   error
-	codes []int
-	ok    bool
-}{
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNormalClosure}, true},
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNoStatusReceived}, false},
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNoStatusReceived, CloseNormalClosure}, true},
-	{errors.New("hello"), []int{CloseNormalClosure}, false},
-}
-
-func TestCloseError(t *testing.T) {
-	for _, tt := range closeErrorTests {
-		ok := IsCloseError(tt.err, tt.codes...)
-		if ok != tt.ok {
-			t.Errorf("IsCloseError(%#v, %#v) returned %v, want %v", tt.err, tt.codes, ok, tt.ok)
-		}
-	}
-}
-
-var unexpectedCloseErrorTests = []struct {
-	err   error
-	codes []int
-	ok    bool
-}{
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNormalClosure}, false},
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNoStatusReceived}, true},
-	{&CloseError{Code: CloseNormalClosure}, []int{CloseNoStatusReceived, CloseNormalClosure}, false},
-	{errors.New("hello"), []int{CloseNormalClosure}, false},
-}
-
-func TestUnexpectedCloseErrors(t *testing.T) {
-	for _, tt := range unexpectedCloseErrorTests {
-		ok := IsUnexpectedCloseError(tt.err, tt.codes...)
-		if ok != tt.ok {
-			t.Errorf("IsUnexpectedCloseError(%#v, %#v) returned %v, want %v", tt.err, tt.codes, ok, tt.ok)
-		}
-	}
-}
-
-type blockingWriter struct {
-	c1, c2 chan struct{}
-}
-
-func (w blockingWriter) Write(p []byte) (int, error) {
-	// Allow main to continue
-	close(w.c1)
-	// Wait for panic in main
-	<-w.c2
-	return len(p), nil
-}
-
-func TestConcurrentWritePanic(t *testing.T) {
-	w := blockingWriter{make(chan struct{}), make(chan struct{})}
-	c := newTestConn(nil, w, false)
-	go func() {
-		c.WriteMessage(TextMessage, []byte{})
-	}()
-
-	// wait for goroutine to block in write.
-	<-w.c1
-
-	defer func() {
-		close(w.c2)
-		if v := recover(); v != nil {
-			return
-		}
-	}()
-
-	c.WriteMessage(TextMessage, []byte{})
-	t.Fatal("should not get here")
-}
-
-type failingReader struct{}
-
-func (r failingReader) Read(p []byte) (int, error) {
-	return 0, io.EOF
-}
-
-func TestFailedConnectionReadPanic(t *testing.T) {
-	c := newTestConn(failingReader{}, nil, false)
-
-	defer func() {
-		if v := recover(); v != nil {
-			return
-		}
-	}()
-
-	for i := 0; i < 20000; i++ {
-		c.ReadMessage()
-	}
-	t.Fatal("should not get here")
-}