package nettest

Import Path
	internal/nettest (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package

Involved Source Files

	    conn.go
	    listener.go
	    packetconn.go
	    queue.go
Package-Level Type Names (total 4)

	/* sort by: alphabet | popularity */
	 type Conn (struct)
		Conn is an in-memory test implementation of net.Conn.

		Methods (total 18)
			(*Conn) CanRead() bool
				CanRead reports whether Read can proceed without blocking.

			(*Conn) Close() error
				Close closes the connection.

			(*Conn) CloseRead() error
				CloseRead shuts down the reading side of the connection.

			(*Conn) CloseWrite() error
				CloseWrite shuts down the writing side of the connection.

			(*Conn) IsClosed() bool
				IsClosed reports whether the connection has been closed.
				A connection is closed if [CloseRead] and [CloseWrite] are both called,
				or if [Close] is called.
				
				To identify when the other side of the Conn has been closed,
				use Conn.Peer().IsClosed().

			(*Conn) LocalAddr() net.Addr
				LocalAddr returns the (fake) local network address.

			(*Conn) Peer() *Conn
				Peer returns the other end of the connection.

			(*Conn) Read(b []byte) (n int, err error)
				Read reads data from the connection.

			(*Conn) RemoteAddr() net.Addr
				LocalAddr returns the (fake) remote network address.

			(*Conn) SetCloseError(err error)
				SetCloseError sets the error returned by Close.
				Close still closes the connection.
				A nil error restores the usual behavior.

			(*Conn) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines for the connection.

			(*Conn) SetLocalAddr(addr net.Addr)
				SetLocalAddr sets the local address.
				
				To set the remote address, set the local address of Conn's peer.

			(*Conn) SetReadBufferSize(size int)
				SetReadBufferSize sets the connection's read buffer.
				Writes to the other end of the connection will block so long as the buffer is full.
				Setting the size to 0 blocks all writes until the size is increased.

			(*Conn) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the read deadline for the connection.

			(*Conn) SetReadError(err error)
				SetReadError causes any currently blocked and future Read calls to return
				a net.OpError wrapping err. It does not affect the other half of the connection.
				Reads will return any buffered data before returning the error,
				including data written after the error is set and io.EOF after the other end is closed.
				A nil error restores the usual behavior.

			(*Conn) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the write deadline for the connection.

			(*Conn) SetWriteError(err error)
				SetWriteError causes any currently blocked and future Write calls to return
				a net.OpError wrapping err. It does not affect the other half of the connection.
				Writes will not write data to the connection buffer while an error is set.
				A nil error restores the usual behavior.

			(*Conn) Write(b []byte) (n int, err error)
				Write writes data to the connection.

		Implements (at least 15)
			*Conn : internal/bisect.Writer
			*Conn : github.com/miekg/dns.Writer
			*Conn : github.com/pion/datachannel.ReadDeadliner
			*Conn : github.com/pion/datachannel.WriteDeadliner
			*Conn : github.com/pion/stun.Connection
			*Conn : github.com/pion/stun/v3.Connection
			*Conn : github.com/prometheus/common/expfmt.Closer
			*Conn : io.Closer
			*Conn : io.ReadCloser
			*Conn : io.Reader
			*Conn : io.ReadWriteCloser
			*Conn : io.ReadWriter
			*Conn : io.WriteCloser
			*Conn : io.Writer
			*Conn : net.Conn
		As Outputs Of (at least 5)
			func NewConnPair() (*Conn, *Conn)
			func NewConnPair() (*Conn, *Conn)
			func (*Conn).Peer() *Conn
			func (*Listener).NewConn() *Conn
			func (*Listener).NewConnConfig(f func(*Conn)) *Conn

	 type Listener (struct)
		Listener is an in-memory test implementation of net.Listener.

		Methods (total 8)
			(*Listener) Accept() (net.Conn, error)
				Accept waits for and returns the next connection to the listener.
				
				The connections returned by Accept are always [*Conn]s.

			(*Listener) Addr() net.Addr
				Addr returns the listener's network address.
				
				The address is always a *net.TCPAddr.

			(*Listener) Close() error
				Close closes the listener.
				Any blocked Accept operations will be unblocked and return errors.

			(*Listener) NewConn() *Conn
				NewConn returns a new connection to the listener.
				
				Accept will return the other side of the conn.

			(*Listener) NewConnConfig(f func(*Conn)) *Conn
				NewConnConfig returns a new connection to the listener.
				
				The function f is called with the new client connection.
				After f returns, Accept will return the other side of the connection.
				
				For example, to create a connection from a specific IP address:
				
					conn := li.NewConnConfig(func(conn *nettest.Conn) {
						conn.SetLocalAddr(net.TCPAddrFromAddrPort(netip.MustParseAddrPort("10.0.0.1:1234")))
					})

			(*Listener) SetAcceptError(err error)
				SetAcceptError causes any currently blocked and future Accept calls to return
				a net.OpError wrapping err.
				Accept will return any available connections before returning the error,
				including connections created after the error is set.
				A nil error restores the usual behavior.

			(*Listener) SetAddr(addr net.Addr)
				SetAddr sets the listener's network address.

			(*Listener) SetCloseError(err error)
				SetCloseError sets the error returned by Close.
				Close still closes the listener.
				A nil error restores the usual behavior.

		Implements (at least 3)
			*Listener : github.com/prometheus/common/expfmt.Closer
			*Listener : io.Closer
			*Listener : net.Listener
		As Outputs Of (at least one exported)
			func NewListener() *Listener

	 type PacketConn (struct)

		Methods (total 12)
			(*PacketConn) CanRead() bool
				CanRead reports whether [ReadFrom] can return at least one byte or an error.
				If [ReadFrom] would block, CanRead returns false.

			(*PacketConn) Close() error
				Close closes the connection.

			(*PacketConn) IsClosed() bool
				IsClosed reports whether the connection has been closed.

			(*PacketConn) LocalAddr() net.Addr
				LocalAddr returns the (fake) local network address.

			(*PacketConn) ReadFrom(b []byte) (n int, addr net.Addr, err error)
				ReadFrom reads a packet from the connection, copying the payload into b.

			(*PacketConn) SetCloseError(err error)
				SetCloseError sets the error returned by Close.
				Close still closes the connection.
				A nil error restores the usual behavior.

			(*PacketConn) SetDeadline(t time.Time) error
				SetReadDeadline sets the read deadline for the connection.
				PacketConns have no write deadline.

			(*PacketConn) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the read deadline for the connection.

			(*PacketConn) SetReadError(err error)
				SetReadError causes any currently blocked and future ReadFrom calls to return
				a net.OpError wrapping err. It does not affect the other half of the connection.
				Reads will return any buffered data before returning the error,
				including data written after the error is set.
				A nil error restores the usual behavior.

			(*PacketConn) SetWriteDeadline(t time.Time) error
				SetWriteDeadline has no effect.
				Writes to PacketConns never block.

			(*PacketConn) SetWriteError(err error)
				SetWriteError causes any currently blocked and future WriteTo calls to return
				a net.OpError wrapping err. It does not affect the other half of the connection.
				Writes will not write data while an error is set.
				A nil error restores the usual behavior.

			(*PacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error)
				WriteTo writes a packet with payload b to addr.
				addr must be a [*net.UDPAddr].
				
				WriteTo appends the packet to the recipient's receive buffer.
				If no recipient is listening on addr or if the recipient's
				receive buffer is full, the packet is silently discarded.

		Implements (at least 5)
			*PacketConn : github.com/pion/datachannel.ReadDeadliner
			*PacketConn : github.com/pion/datachannel.WriteDeadliner
			*PacketConn : github.com/prometheus/common/expfmt.Closer
			*PacketConn : io.Closer
			*PacketConn : net.PacketConn
		As Outputs Of (at least one exported)
			func (*PacketNet).NewConn(a net.Addr) (*PacketConn, error)

	 type PacketNet (struct)
		A PacketNet is a group of communicating [PacketConn]s.

		Methods (only one)
			(*PacketNet) NewConn(a net.Addr) (*PacketConn, error)
				NewConn returns a new [PacketConn] listening on the given address.
				It returns an error if there is an existing listener on this address.

		As Outputs Of (at least one exported)
			func NewPacketNet() *PacketNet


Package-Level Functions (total 3)

	 func NewConnPair() (*Conn, *Conn)
		NewConnPair returns a pair of connected Conns.

	 func NewListener() *Listener
		NewListener returns a new Listener.

	 func NewPacketNet() *PacketNet
		NewPacketNet returns a new PacketNet.

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.