hunk.code_window:                     width={this.props.width}
                       height={this.props.width}
                       src={this.props.src}
                       crossOrigin='anonymous'
                   />
                   <StatusIcon status={this.props.status}/>
               </span>
  
hunk.labels: keep keep keep replace keep keep keep
hunk.file_path: webapp/components/profile_picture.jsx
hunk.type: replace
file: // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
  //
  // Copyright 2016 The Go-MySQL-Driver Authors. All rights reserved.
  //
  // This Source Code Form is subject to the terms of the Mozilla Public
  // License, v. 2.0. If a copy of the MPL was not distributed with this file,
  // You can obtain one at http://mozilla.org/MPL/2.0/.
  
  package mysql
  
  import (
  	"database/sql/driver"
  	"errors"
  	"net"
  	"testing"
  	"time"
  )
  
  var (
  	errConnClosed        = errors.New("connection is closed")
  	errConnTooManyReads  = errors.New("too many reads")
  	errConnTooManyWrites = errors.New("too many writes")
  )
  
  // struct to mock a net.Conn for testing purposes
  type mockConn struct {
  	laddr     net.Addr
  	raddr     net.Addr
  	data      []byte
  	closed    bool
  	read      int
  	written   int
  	reads     int
  	writes    int
  	maxReads  int
  	maxWrites int
  }
  
  func (m *mockConn) Read(b []byte) (n int, err error) {
  	if m.closed {
  		return 0, errConnClosed
  	}
  
  	m.reads++
  	if m.maxReads > 0 && m.reads > m.maxReads {
  		return 0, errConnTooManyReads
  	}
  
  	n = copy(b, m.data)
  	m.read += n
  	m.data = m.data[n:]
  	return
  }
  func (m *mockConn) Write(b []byte) (n int, err error) {
  	if m.closed {
  		return 0, errConnClosed
  	}
  
  	m.writes++
  	if m.maxWrites > 0 && m.writes > m.maxWrites {
  		return 0, errConnTooManyWrites
  	}
  
  	n = len(b)
  	m.written += n
  	return
  }
  func (m *mockConn) Close() error {
  	m.closed = true
  	return nil
  }
  func (m *mockConn) LocalAddr() net.Addr {
  	return m.laddr
  }
  func (m *mockConn) RemoteAddr() net.Addr {
  	return m.raddr
  }
  func (m *mockConn) SetDeadline(t time.Time) error {
  	return nil
  }
  func (m *mockConn) SetReadDeadline(t time.Time) error {
  	return nil
  }
  func (m *mockConn) SetWriteDeadline(t time.Time) error {
  	return nil
  }
  
  // make sure mockConn implements the net.Conn interface
  var _ net.Conn = new(mockConn)
  
  func TestReadPacketSingleByte(t *testing.T) {
  	conn := new(mockConn)
  	mc := &mysqlConn{
  		buf: newBuffer(conn),
  	}
  
  	conn.data = []byte{0x01, 0x00, 0x00, 0x00, 0xff}
  	conn.maxReads = 1
  	packet, err := mc.readPacket()
  	if err != nil {
  		t.Fatal(err)
  	}
  	if len(packet) != 1 {
  		t.Fatalf("unexpected packet lenght: expected %d, got %d", 1, len(packet))
  	}
  	if packet[0] != 0xff {
  		t.Fatalf("unexpected packet content: expected %x, got %x", 0xff, packet[0])
  	}
  }
  
  func TestReadPacketWrongSequenceID(t *testing.T) {
  	conn := new(mockConn)
  	mc := &mysqlConn{
  		buf: newBuffer(conn),
  	}
  
  	// too low sequence id
  	conn.data = []byte{0x01, 0x00, 0x00, 0x00, 0xff}
  	conn.maxReads = 1
  	mc.sequence = 1
  	_, err := mc.readPacket()
  	if err != ErrPktSync {
  		t.Errorf("expected ErrPktSync, got %v", err)
  	}
  
  	// reset
  	conn.reads = 0
  	mc.sequence = 0
  	mc.buf = newBuffer(conn)
  
  	// too high sequence id
  	conn.data = []byte{0x01, 0x00, 0x00, 0x42, 0xff}
  	_, err = mc.readPacket()
  	if err != ErrPktSyncMul {
  		t.Errorf("expected ErrPktSyncMul, got %v", err)
  	}
  }
  
  func TestReadPacketSplit(t *testing.T) {
  	conn := new(mockConn)
  	mc := &mysqlConn{
  		buf: newBuffer(conn),
  	}
  
  	data := make([]byte, maxPacketSize*2+4*3)
  	const pkt2ofs = maxPacketSize + 4
  	const pkt3ofs = 2 * (maxPacketSize + 4)
  
  	// case 1: payload has length maxPacketSize
  	data = data[:pkt2ofs+4]
  
  	// 1st packet has maxPacketSize length and sequence id 0
  	// ff ff ff 00 ...
  	data[0] = 0xff
  	data[1] = 0xff
  	data[2] = 0xff
  
  	// mark the payload start and end of 1st packet so that we can check if the
  	// content was correctly appended
  	data[4] = 0x11
  	data[maxPacketSize+3] = 0x22
  
  	// 2nd packet has payload length 0 and squence id 1
  	// 00 00 00 01
  	data[pkt2ofs+3] = 0x01
  
  	conn.data = data
  	conn.maxReads = 3
  	packet, err := mc.readPacket()
  	if err != nil {
  		t.Fatal(err)
  	}
  	if len(packet) != maxPacketSize {
  		t.Fatalf("unexpected packet lenght: expected %d, got %d", maxPacketSize, len(packet))
  	}
  	if packet[0] != 0x11 {
  		t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
  	}
  	if packet[maxPacketSize-1] != 0x22 {
  		t.Fatalf("unexpected payload end: expected %x, got %x", 0x22, packet[maxPacketSize-1])
  	}
  
  	// case 2: payload has length which is a multiple of maxPacketSize
  	data = data[:cap(data)]
  
  	// 2nd packet now has maxPacketSize length
  	data[pkt2ofs] = 0xff
  	data[pkt2ofs+1] = 0xff
  	data[pkt2ofs+2] = 0xff
  
  	// mark the payload start and end of the 2nd packet
  	data[pkt2ofs+4] = 0x33
  	data[pkt2ofs+maxPacketSize+3] = 0x44
  
  	// 3rd packet has payload length 0 and squence id 2
  	// 00 00 00 02
  	data[pkt3ofs+3] = 0x02
  
  	conn.data = data
  	conn.reads = 0
  	conn.maxReads = 5
  	mc.sequence = 0
  	packet, err = mc.readPacket()
  	if err != nil {
  		t.Fatal(err)
  	}
  	if len(packet) != 2*maxPacketSize {
  		t.Fatalf("unexpected packet lenght: expected %d, got %d", 2*maxPacketSize, len(packet))
  	}
  	if packet[0] != 0x11 {
  		t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
  	}
  	if packet[2*maxPacketSize-1] != 0x44 {
  		t.Fatalf("unexpected payload end: expected %x, got %x", 0x44, packet[2*maxPacketSize-1])
  	}
  
  	// case 3: payload has a length larger maxPacketSize, which is not an exact
  	// multiple of it
  	data = data[:pkt2ofs+4+42]
  	data[pkt2ofs] = 0x2a
  	data[pkt2ofs+1] = 0x00
  	data[pkt2ofs+2] = 0x00
  	data[pkt2ofs+4+41] = 0x44
  
  	conn.data = data
  	conn.reads = 0
  	conn.maxReads = 4
  	mc.sequence = 0
  	packet, err = mc.readPacket()
  	if err != nil {
  		t.Fatal(err)
  	}
  	if len(packet) != maxPacketSize+42 {
  		t.Fatalf("unexpected packet lenght: expected %d, got %d", maxPacketSize+42, len(packet))
  	}
  	if packet[0] != 0x11 {
  		t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
  	}
  	if packet[maxPacketSize+41] != 0x44 {
  		t.Fatalf("unexpected payload end: expected %x, got %x", 0x44, packet[maxPacketSize+41])
  	}
  }
  
  func TestReadPacketFail(t *testing.T) {
  	conn := new(mockConn)
  	mc := &mysqlConn{
  		buf: newBuffer(conn),
  	}
  
  	// illegal empty (stand-alone) packet
  	conn.data = []byte{0x00, 0x00, 0x00, 0x00}
  	conn.maxReads = 1
  	_, err := mc.readPacket()
  	if err != driver.ErrBadConn {
  		t.Errorf("expected ErrBadConn, got %v", err)
  	}
  
  	// reset
  	conn.reads = 0
  	mc.sequence = 0
  	mc.buf = newBuffer(conn)
  
  	// fail to read header
  	conn.closed = true
  	_, err = mc.readPacket()
  	if err != driver.ErrBadConn {
  		t.Errorf("expected ErrBadConn, got %v", err)
  	}
  
  	// reset
  	conn.closed = false
  	conn.reads = 0
  	mc.sequence = 0
  	mc.buf = newBuffer(conn)
  
  	// fail to read body
  	conn.maxReads = 1
  	_, err = mc.readPacket()
  	if err != driver.ErrBadConn {
  		t.Errorf("expected ErrBadConn, got %v", err)
  	}
  }
  