import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2
import okhttp3.internal.platform.android.AndroidLog.androidLog

private val LogRecord.androidLevel: Int
  get() =
    when {
      level.intValue() > Level.INFO.intValue() -> Log.WARN
      level.intValue() == Level.INFO.intValue() -> Log.INFO
      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {

        withTimeout(1.seconds) {
          call.executeAsync().use {
            withContext(Dispatchers.IO) {
              it.body.string()
            }
            fail("No expected to get response")
          }
        }
      }

      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun cancelledCall() {
    runTest {
      server.enqueue(

     * @return the default filter chain implementation
     */
    protected FilterChain createDefaultFilterChain() {
        return (context, query, boost) -> {
            final QueryCommand queryCommand = queryCommandMap.get(query.getClass().getSimpleName());
            if (queryCommand != null) {
                return queryCommand.execute(context, query, boost);
            }

        assertNotNull(r);
        assertTrue(r.getName().startsWith("TAKEME"));

        // The first filtered resource name should correspond to the rejected entry
        assertTrue(captor.getAllValues().get(0).getName().startsWith("SKIPME"));
    }

    @Test
    @DisplayName("close() delegates to underlying iterator")
    void closeDelegates() throws Exception {

The MinIO TLS STS API can be configured via MinIO's standard configuration API (i.e. using `mc admin config set/get`). Further, it can be configured via the following environment variables:

```
mc admin config set myminio identity_tls --env
KEY:
identity_tls  enable X.509 TLS certificate SSO support

ARGS:

* `allow_methods` - A list of HTTP methods that should be allowed for cross-origin requests. Defaults to `['GET']`. You can use `['*']` to allow all standard methods.

            this.lastResolver = resolver;
            this.resolverCalled = true;
        }

        @Override
        public ActionResponse getResponse(SsoResponseType responseType) {
            return responseMap.get(responseType);
        }

        @Override
        public String logout(FessUserBean userBean) {
            this.lastLogoutUser = userBean;
            return logoutUrl;
        }
    }

```Python
results = await some_library()
```

В этом случае *функции обработки пути* необходимо объявлять с использованием синтаксиса `async def`:

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

/// note

`await` можно использовать только внутри функций, объявленных с использованием `async def`.

///

  public void testRemove_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getMap().remove(k0()));
    expectUnchanged();
    assertEquals("remove(present) should not remove the element", v0(), get(k0()));
  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertNull(

        ) {
        }
      },
    )

    // This should fail the Call, but not cause an unhandled Exception bubbling up
    client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message).isEqualTo("canceled due to java.lang.InterruptedException")
    assertThat(exception).isInstanceOf<IOException>()
    assertThat(exception.cause)
      .isNotNull()