synchronized (this) {
        if (!isThreadScheduled) {
          isThreadScheduled = true;
          scheduleEventRunner = true;
        }
      }
      if (scheduleEventRunner) {
        try {
          executor.execute(this);
        } catch (Exception e) { // sneaky checked exception
          // reset state in case of an error so that later dispatch calls will actually do something

     * @param lastWriteTime
     * @throws SmbException
     */
    void closeInternal(final long lastWriteTime, final boolean explicit) throws CIFSException {
        final SmbTreeHandleImpl t = this.tree;
        try {
            if (t != null && isValid()) {
                if (log.isDebugEnabled()) {
                    log.debug("Closing file handle " + this);
                }

                if (t.isSMB2()) {

     * Verifies that SmbTree can be used in try-with-resources.
     */
    @Test
    void testAutoCloseable() {
        SmbTree autoCloseTree = mock(SmbTree.class);
        doNothing().when(autoCloseTree).close();

        try (SmbTree tree = autoCloseTree) {
            assertNotNull(tree, "Tree should not be null in try block");
        }

        verify(autoCloseTree).close();
    }

     */
    public static List<String> getKeywords(final String q, final String[] fields) {
        final List<String> keywords = new ArrayList<>();
        final List<TermQuery> termQueryList;
        try {
            final StandardQueryParser parser = new StandardQueryParser();
            parser.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);

        };

        final ResponseData responseData = new ResponseData();
        responseData.setUrl("http://example.com/");
        responseData.addMetaData("X-Robots-Tag", "noindex,nofollow");

        try {
            transformer.processXRobotsTag(responseData, new ResultData());
            fail();
        } catch (ChildUrlsException e) {
            assertTrue(e.getChildUrlList().isEmpty());

/**
 * A policy for how the pool should treat a specific address.
 */
class AddressPolicy(
  /**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
   */
  @JvmField val minimumConcurrentCalls: Int = 0,

                return webApiManager;
            }
        };
        ComponentUtil.register(factory, "webApiManagerFactory");

        // Execute and expect IOException
        try {
            webApiFilter.doFilter(request, response, chain);
            fail("Expected IOException");
        } catch (IOException e) {
            assertEquals("Test IOException", e.getMessage());

/// tip

You can use `async` or regular functions.

**FastAPI** will do the right thing with each, the same as with normal dependencies.

///

## A dependency with `yield` and `try` { #a-dependency-with-yield-and-try }

If you use a `try` block in a dependency with `yield`, you'll receive any exception that was thrown when using the dependency.

 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`
 * block. With this structure the compiler inserts an implicit `finally` clause that calls
 * [close()][Response.close] for you.
 *
 * ```java
 * Call call = client.newCall(request);
 * try (Response response = call.execute()) {
 * ... // Use the response.
 * }
 * ```
 *

  }

  private <T> void assertFailure(
      Class<T> interfaceType,
      Function<T, ? extends T> wrapperFunction,
      String... expectedMessages) {
    try {
      tester.testForwarding(interfaceType, wrapperFunction);
    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);