// Test that listeners added both before and after the value is available
    // get called correctly.
    for (int i = 0; i < 20; i++) {

      // Right in the middle start up a thread to close the latch.
      if (i == 10) {
        new Thread(() -> latch.countDown()).start();
      }

      future.addListener(listenerLatch::countDown, exec);
    }

    assertSame(Boolean.TRUE, future.get());

    assertThrows(IllegalArgumentException.class, () -> reader.mark(-1));
  }

  public void testMethodsThrowWhenClosed() throws IOException {
    CharSequenceReader reader = new CharSequenceReader("");
    reader.close();

    assertThrows(IOException.class, () -> reader.read());

    assertThrows(IOException.class, () -> reader.read(new char[10]));

    assertThrows(IOException.class, () -> reader.read(new char[10], 0, 10));

## `fastapi run`

Executing `fastapi run` starts FastAPI in production mode by default.

    field: ModelField,
    *,
    cloned_types: Optional[MutableMapping[Type[BaseModel], Type[BaseModel]]] = None,
) -> ModelField:
    if PYDANTIC_V2:
        return field
    # cloned_types caches already cloned types to support recursive models and improve
    # performance by avoiding unnecessary cloning
    if cloned_types is None:
        cloned_types = _CLONED_TYPES_CACHE

    original_type = field.type_

		return err
	}

	targetList, err := fetchSubSysTargets(ctx, cfg, subSys, transport)
	if err != nil {
		return err
	}

	for _, target := range targetList {
		defer target.Close()
	}

	for _, target := range targetList {
		yes, err := target.IsActive()
		if err == nil && !yes {
			err = ErrTargetsOffline
		}
		if err != nil {
			return fmt.Errorf("error (%s): %w", target.ID(), err)

	if lrw.Header().Get("Content-Encoding") == "gzip" {
		if lrw.body.Len() > 1<<20 {
			return gzippedBody
		}
		r, err := gzip.NewReader(&lrw.body)
		if err != nil {
			return gzippedBody
		}
		defer r.Close()
		b, _ := io.ReadAll(io.LimitReader(r, 10<<20))
		return b
	}
	// If there was an error response or body logging is enabled
	// then we return the body contents

             * because we might close the socket during a
             * request. However the chances are slim and the
             * retry code should ensure the overall request
             * is serviced. The alternative complicates things
             * more than I think is worth it.
             */

            if( socket != null ) {
                socket.close();
                socket = null;
            }

func (m *Manager) IncomingConn(ctx context.Context, conn net.Conn) {
	remoteAddr := conn.RemoteAddr().String()
	// will write an OpConnectResponse message to the remote and log it once locally.
	defer conn.Close()
	writeErr := func(err error) {
		if err == nil {
			return
		}
		if errors.Is(err, io.EOF) {
			return
		}
		gridLogOnceIf(ctx, err, remoteAddr)
		resp := connectResp{
			ID:             m.ID,

This can help ensure that clients do not hold onto pooled connections for too long.
This is not strictly required; Ztunnel clients have both keepalives (which will start to fail once the other end is shut down) and pool idle timeouts (which will close the connection when it has had no activity for some period; because the backend is gone, there will be no activity).
However, it would be ideal to give immediate feedback rather than relying on these mechanisms.

         * InterruptibleChannel and JavaLangAccess.blockedOn(Thread, Interruptible), it isn't
         * predictable what work might be done. (e.g., close a file and flush buffers to disk). To
         * protect ourselves from this, we park ourselves and tell our interrupter that we did so.
         */
        if (state == PARKED || compareAndSet(state, PARKED)) {