func (listener *httpListener) start() {
	// Closure to handle listener until httpListener.ctxDoneCh channel is closed.
	handleListener := func(idx int, ln net.Listener) {
		for {
			conn, err := ln.Accept()
			select {
			case listener.acceptCh <- acceptResult{conn, err, idx}:
			case <-listener.ctxDoneCh:
				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {

// ServeHTTP forwards HTTP traffic using the configured transport
func (f *Forwarder) ServeHTTP(w http.ResponseWriter, inReq *http.Request) {
	outReq := new(http.Request)
	*outReq = *inReq // includes shallow copies of maps, but we handle this in Director

	revproxy := httputil.ReverseProxy{
		Director: func(req *http.Request) {
			f.modifyRequest(req, inReq.URL)
		},
		BufferPool:    newBufPool(128 << 10),
		Transport:     f.RoundTripper,

    class LifecycleAndExceptions {

        @Test
        @DisplayName("open() acquires handle and closes it")
        void openDelegatesEnsureOpenAndCloses() throws Exception {
            SmbFileInputStream in = newStream();
            in.open();
            // ensureOpen returns acquired handle; try-with-resources must close it
            verify(mockHandle, times(1)).close();

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

/**
 * Simple derived class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class DerivedComparable extends BaseComparable {
  public DerivedComparable(String s) {
    super(s);
  }

## Accessing the request body in an exception handler { #accessing-the-request-body-in-an-exception-handler }

/// tip

To solve this same problem, it's probably a lot easier to use the `body` in a custom handler for `RequestValidationError` ([Handling Errors](../tutorial/handling-errors.md#use-the-requestvalidationerror-body)).

 */
package mockwebserver3

import okio.Socket

/**
 * Handles a call's request and response streams directly. Use this instead of [MockResponseBody] to
 * begin sending response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
public interface SocketHandler {
  public fun handle(socket: Socket)

         */
        public boolean hasWriteCache() {
            return Smb2LeaseState.hasWriteCaching(leaseState);
        }

        /**
         * Check if lease has handle caching
         *
         * @return true if handle caching is enabled
         */
        public boolean hasHandleCache() {
            return Smb2LeaseState.hasHandleCaching(leaseState);
        }

        /**

        assertEquals(4, bytesWritten);
        assertEquals(4, SMBUtil.readInt2(buffer, offset));
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));
    }

    @Test
    @DisplayName("Should handle boundary conditions for buffer write")
    void testWriteBytesWireFormatBoundary() {
        // Given
        Configuration mockConfig = mock(Configuration.class);

    /**
     * Construct bind message
     *
     */
    public DcerpcBind() {
    }

    DcerpcBind(final DcerpcBinding binding, final DcerpcHandle handle) {
        this.binding = binding;
        this.max_xmit = handle.getMaxXmit();
        this.max_recv = handle.getMaxRecv();
        this.ptype = 11;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    @Override
    public int getOpnum() {

    /**
     * Constructs a new DcerpcBind message.
     */
    public DcerpcBind() {
    }

    DcerpcBind(final DcerpcBinding binding, final DcerpcHandle handle) {
        this.binding = binding;
        max_xmit = handle.max_xmit;
        max_recv = handle.max_recv;
        ptype = 11;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    @Override
    public int getOpnum() {
        return 0;
    }