# 测试事件：启动 - 关闭

使用 `TestClient` 和 `with` 语句，在测试中运行事件处理器（`startup` 与 `shutdown`）。

        .url("http://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      System.out.println(response.body().string());
    }

    server.shutdown();
    socketFile.delete();
  }

  public static void main(String... args) throws Exception {
    new ClientAndServer().run();
  }

   */
  @ForOverride
  protected abstract void doStart();

  /**
   * This method should be used to initiate service shutdown. The invocation of this method should
   * cause a call to {@link #notifyStopped()}, either during this method's run, or after it has
   * returned. If shutdown fails, the invocation should cause a call to {@link
   * #notifyFailed(Throwable)} instead.
   *

    override fun execute(
      taskRunner: TaskRunner,
      runnable: Runnable,
    ) {
      executor.execute(runnable)
    }

    fun shutdown() {
      executor.shutdown()
    }
  }

  companion object {
    val logger: Logger = Logger.getLogger(TaskRunner::class.java.name)

    @JvmField

    proceed.countDown()
    t1.join()
    assertThat(idle.get()).isTrue()
  }

  @Test
  fun executionRejectedImmediately() {
    val request = newRequest("http://a/1")
    executor.shutdown()
    client.newCall(request).enqueue(callback)
    callback.await(request.url).assertFailure(InterruptedIOException::class.java)
    assertThat(eventRecorder.recordedEventTypes())

                    this.transport.release();
                }

                // Shutdown channel manager
                if (this.channelManager != null) {
                    this.channelManager.shutdown();
                    this.channelManager = null;
                }

                // Shutdown witness client
                if (this.witnessClient != null) {
                    this.witnessClient.close();

            // Recovery not possible, remove synchronously
            removeChannel(failedChannel);
            return;
        }
    }

    /**
     * Shutdown the failover handler
     */
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }

        response = client.get("/items/")
        assert response.status_code == 200, response.text
        assert response.json() == [{"name": "Foo"}]
    with open("log.txt") as log:
        assert "Application shutdown" in log.read()


def test_openapi_schema(app: FastAPI):
    with TestClient(app) as client:
        response = client.get("/openapi.json")
        assert response.status_code == 200, response.text

    }

    /**
     * Shutdown the channel manager
     */
    public void shutdown() {
        scheduler.shutdown();
        failover.shutdown();

        for (ChannelInfo channel : channels.values()) {
            try {
                channel.getTransport().close();

    Proxy(
      Proxy.Type.SOCKS,
      InetSocketAddress.createUnresolved("localhost", serverSocket!!.localPort),
    )

  fun connectionCount(): Int = connectionCount.get()

  fun shutdown() {
    serverSocket!!.close()
    executor.shutdown()
    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
      throw IOException("Gave up waiting for executor to shut down")
    }
  }

  private fun service(from: Socket) {