states := make([]madmin.BgHealState, len(sys.peerClients))
	for idx, client := range sys.peerClients {
		client := client
		ng.Go(ctx, func() error {
			if client == nil {
				return errPeerNotReachable
			}
			st, err := client.BackgroundHealStatus(ctx)
			if err != nil {
				return err
			}
			states[idx] = st
			return nil
		}, idx, *client.host)
	}

	return states, ng.Wait()
}

@pytest.fixture(scope="module")
def client() -> Iterator[TestClient]:
    with TestClient(app) as client:
        yield client


def _bench_get(benchmark, client: TestClient, path: str) -> tuple[int, bytes]:
    warmup = client.get(path)
    assert warmup.status_code == 200

    def do_request() -> tuple[int, bytes]:
        response = client.get(path)
        return response.status_code, response.content

import org.opensearch.threadpool.ThreadPool;
import org.opensearch.transport.client.AdminClient;
import org.opensearch.transport.client.Client;

import jakarta.annotation.PreDestroy;

/**
 * FesenClient is a client for OpenSearch.
 *
 * @author shinsuke
 *
 */
public class FesenClient implements Client {
    /**
     * HTTP address for OpenSearch.
     */

    with client:
        response = client.get("/a/override")
    assert response.content == b"Hello A"
    assert response.headers["content-type"] == text_type


def test_router_a_a():
    with client:
        response = client.get("/a/a")
    assert response.json() == {"msg": "Hello A A"}
    assert response.headers["content-type"] == json_type


def test_router_a_a_override():
    with client:

        value = props.getProperty("jcifs.smb.client.username");
        if (value != null) {
            this.defaultUserName = value;
        }

        value = props.getProperty("jcifs.smb.client.password");
        if (value != null) {
            this.defaultPassword = value;
        }

        value = props.getProperty("jcifs.smb.client.domain");
        if (value != null) {

        .message("Intercepted!")
        .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
        .build()
    client =
      client
        .newBuilder()
        .addInterceptor(Interceptor { chain: Interceptor.Chain? -> interceptorResponse })
        .build()
    val response = client.newCall(request).execute()
    assertThat(response).isSameInstanceAs(interceptorResponse)
  }

  @Test

    client = DummyClient()
    yield client
    await client.close()


Client = Annotated[DummyClient, Depends(get_client)]


@pytest.fixture(name="client")
def client_fixture() -> TestClient:
    app = FastAPI()

    @app.get("/")
    async def get_people(client: Client) -> list:
        return await client.get_people()

    client = TestClient(app)
    return client

    client.processNextFrame() // Read server close, send client close, close connection.
    assertThat(client.closed).isFalse()
    client.listener.assertClosing(1000, "Hello!")
    client.webSocket!!.finishReader()
    client.webSocket!!.close(1000, "Hello!")
    server.processNextFrame()
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    client.listener.assertClosed(1000, "Hello!")

    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)
  }

  @Test
  fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
    client =
      client
        .newBuilder()

@pytest.fixture(
    name="client",
    params=[
        pytest.param("tutorial002_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.body_multiple_params.{request.param}")

    client = TestClient(mod.app)
    return client


def test_post_all(client: TestClient):
    response = client.put(
        "/items/5",
        json={