// for them to close, if desired. See [Server.RegisterOnShutdown] for a way to
// register shutdown notification functions.
//
// Once Shutdown has been called on a server, it may not be reused;
// future calls to methods such as Serve will return ErrServerClosed.
func (srv *Server) Shutdown(ctx context.Context) error {
	srv.inShutdown.Store(true)

	srv.mu.Lock()
	lnerr := srv.closeListenersLocked()

		if n != 1<<20 || err != nil {
			t.Errorf("client read response body: %d, %v", n, err)
		}
		// This shutdown really should be automatic, but it isn't right now.
		// Shutdown (rather than Close) ensures the handler is done before we return.
		res.Body.Close()
		cst.ts.Config.Shutdown(context.Background())
	}
}

// Test that the HTTP/2 server handles Server.WriteTimeout (Issue 18437)

      functionCalled.await();
      assertThat(output.toString()).contains(function.toString());
    } finally {
      functionBlocking.countDown();
      executor.shutdown();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // lazyTransform
  public void testLazyTransform() throws Exception {
    FunctionSpy<Object, String> spy = new FunctionSpy<>(constant("bar"));

      functionCalled.await();
      assertThat(output.toString()).contains(function.toString());
    } finally {
      functionBlocking.countDown();
      executor.shutdown();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // lazyTransform
  public void testLazyTransform() throws Exception {
    FunctionSpy<Object, String> spy = new FunctionSpy<>(constant("bar"));

	t.Add(item)
}
func (t *trackingWorkqueue[T]) AddRateLimited(item T) {
	t.Add(item)
}
func (t *trackingWorkqueue[T]) Get() (T, bool) {
	item, shutdown := t.limiter.Get()
	t.dequeue(item)
	return item, shutdown
}
func (t *trackingWorkqueue[T]) Done(item T) {
	t.limiter.Done(item)
}
func (t *trackingWorkqueue[T]) Forget(item T) {
	t.limiter.Forget(item)
}

	go kl.pluginManager.Run(kl.sourcesReady, wait.NeverStop)

	err = kl.shutdownManager.Start()
	if err != nil {
		// The shutdown manager is not critical for kubelet, so log failure, but don't block Kubelet startup if there was a failure starting it.
		klog.ErrorS(err, "Failed to start node shutdown manager")
	}
}

// Run starts the kubelet reacting to config updates

                """
            ),
        ] = None,
        on_shutdown: Annotated[
            Optional[Sequence[Callable[[], Any]]],
            Doc(
                """
                A list of shutdown event handler functions.

                You should instead use the `lifespan` handlers.

                Read more in the
                [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).

    assertFailsWith<IOException> {
      getResponse(request)
    }
  }

  @Test
  fun connectRetriesUntilConnectedOrFailed() {
    val request = newRequest("/foo")
    server.shutdown()
    assertFailsWith<IOException> {
      getResponse(request)
    }
  }

  @Test
  fun requestBodySurvivesRetriesWithFixedLength() {
    testRequestBodySurvivesRetries(TransferKind.FIXED_LENGTH)

    val cached = cacheGet(cache, request)
    if (shouldWriteToCache) {
      assertThat(cached).isNotNull()
      cached!!.body.close()
    } else {
      assertThat(cached).isNull()
    }
    server.shutdown() // tearDown() isn't sufficient; this test starts multiple servers
  }

  private fun assertSubsequentResponseCached(
    initialResponseCode: Int,
    finalResponseCode: Int,
  ) {

                """
            ),
        ] = None,
        on_shutdown: Annotated[
            Optional[Sequence[Callable[[], Any]]],
            Doc(
                """
                A list of shutdown event handler functions.

                You should instead use the `lifespan` handlers.

                Read more in the
                [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).