hunk.code_window: 	if len(rmembers) != 0 {
   		t.Fatal("should be no member")
   	}
   	_, resp = Client.GetTeamMembers("junk", 0, 100, "")
   	CheckBadRequestStatus(t, resp)
  
hunk.labels: keep keep keep add keep keep keep
hunk.after_edit: 	rmembers, resp = Client.GetTeamMembers(team.Id, 0, 2, "")
   	CheckNoError(t, resp)
   	rmembers2, resp := Client.GetTeamMembers(team.Id, 1, 2, "")
   	CheckNoError(t, resp)
   	for _, tm1 := range rmembers {
   		for _, tm2 := range rmembers2 {
   			assert.NotEqual(t, tm1.UserId+tm1.TeamId, tm2.UserId+tm2.TeamId, "different pages should not have the same members")
   		}
   	}
  
hunk.file_path: api4/team_test.go
hunk.type: add
file: // Copyright 2017 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // +build go1.9
  
  package ipv4
  
  import (
  	"net"
  	"runtime"
  	"syscall"
  
  	"golang.org/x/net/internal/socket"
  )
  
  // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of
  // PacketConn are not implemented.
  
  // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of
  // RawConn are not implemented.
  
  // A Message represents an IO message.
  //
  //	type Message struct {
  //		Buffers [][]byte
  //		OOB     []byte
  //		Addr    net.Addr
  //		N       int
  //		NN      int
  //		Flags   int
  //	}
  //
  // The Buffers fields represents a list of contiguous buffers, which
  // can be used for vectored IO, for example, putting a header and a
  // payload in each slice.
  // When writing, the Buffers field must contain at least one byte to
  // write.
  // When reading, the Buffers field will always contain a byte to read.
  //
  // The OOB field contains protocol-specific control or miscellaneous
  // ancillary data known as out-of-band data.
  // It can be nil when not required.
  //
  // The Addr field specifies a destination address when writing.
  // It can be nil when the underlying protocol of the endpoint uses
  // connection-oriented communication.
  // After a successful read, it may contain the source address on the
  // received packet.
  //
  // The N field indicates the number of bytes read or written from/to
  // Buffers.
  //
  // The NN field indicates the number of bytes read or written from/to
  // OOB.
  //
  // The Flags field contains protocol-specific information on the
  // received message.
  type Message = socket.Message
  
  // ReadBatch reads a batch of messages.
  //
  // The provided flags is a set of platform-dependent flags, such as
  // syscall.MSG_PEEK.
  //
  // On a successful read it returns the number of messages received, up
  // to len(ms).
  //
  // On Linux, a batch read will be optimized.
  // On other platforms, this method will read only a single message.
  //
  // Unlike the ReadFrom method, it doesn't strip the IPv4 header
  // followed by option headers from the received IPv4 datagram when the
  // underlying transport is net.IPConn. Each Buffers field of Message
  // must be large enough to accommodate an IPv4 header and option
  // headers.
  func (c *payloadHandler) ReadBatch(ms []Message, flags int) (int, error) {
  	if !c.ok() {
  		return 0, syscall.EINVAL
  	}
  	switch runtime.GOOS {
  	case "linux":
  		n, err := c.RecvMsgs([]socket.Message(ms), flags)
  		if err != nil {
  			err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	default:
  		n := 1
  		err := c.RecvMsg(&ms[0], flags)
  		if err != nil {
  			n = 0
  			err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	}
  }
  
  // WriteBatch writes a batch of messages.
  //
  // The provided flags is a set of platform-dependent flags, such as
  // syscall.MSG_DONTROUTE.
  //
  // It returns the number of messages written on a successful write.
  //
  // On Linux, a batch write will be optimized.
  // On other platforms, this method will write only a single message.
  func (c *payloadHandler) WriteBatch(ms []Message, flags int) (int, error) {
  	if !c.ok() {
  		return 0, syscall.EINVAL
  	}
  	switch runtime.GOOS {
  	case "linux":
  		n, err := c.SendMsgs([]socket.Message(ms), flags)
  		if err != nil {
  			err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	default:
  		n := 1
  		err := c.SendMsg(&ms[0], flags)
  		if err != nil {
  			n = 0
  			err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	}
  }
  
  // ReadBatch reads a batch of messages.
  //
  // The provided flags is a set of platform-dependent flags, such as
  // syscall.MSG_PEEK.
  //
  // On a successful read it returns the number of messages received, up
  // to len(ms).
  //
  // On Linux, a batch read will be optimized.
  // On other platforms, this method will read only a single message.
  func (c *packetHandler) ReadBatch(ms []Message, flags int) (int, error) {
  	if !c.ok() {
  		return 0, syscall.EINVAL
  	}
  	switch runtime.GOOS {
  	case "linux":
  		n, err := c.RecvMsgs([]socket.Message(ms), flags)
  		if err != nil {
  			err = &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	default:
  		n := 1
  		err := c.RecvMsg(&ms[0], flags)
  		if err != nil {
  			n = 0
  			err = &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	}
  }
  
  // WriteBatch writes a batch of messages.
  //
  // The provided flags is a set of platform-dependent flags, such as
  // syscall.MSG_DONTROUTE.
  //
  // It returns the number of messages written on a successful write.
  //
  // On Linux, a batch write will be optimized.
  // On other platforms, this method will write only a single message.
  func (c *packetHandler) WriteBatch(ms []Message, flags int) (int, error) {
  	if !c.ok() {
  		return 0, syscall.EINVAL
  	}
  	switch runtime.GOOS {
  	case "linux":
  		n, err := c.SendMsgs([]socket.Message(ms), flags)
  		if err != nil {
  			err = &net.OpError{Op: "write", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	default:
  		n := 1
  		err := c.SendMsg(&ms[0], flags)
  		if err != nil {
  			n = 0
  			err = &net.OpError{Op: "write", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
  		}
  		return n, err
  	}
  }
  