try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
  }

  /** Tests that the {@link Future#get(long, TimeUnit)} method times out correctly. */

 *
 * @author Jesse Wilson
 */
@NullUnmarked
public class ReentrantEventsTest extends TestCase {

  static final String FIRST = "one";
  static final Double SECOND = 2.0d;

  final EventBus bus = new EventBus();

  public void testNoReentrantEvents() {
    ReentrantEventsHater hater = new ReentrantEventsHater();
    bus.register(hater);

    bus.post(FIRST);

      call.eventListener.connectFailed(call, route.socketAddress, route.proxy, null, e)
      connectionPool.connectionListener.connectFailed(route, call, e)
      return ConnectResult(plan = this, throwable = e)
    } finally {
      call.plansToCancel -= this
      if (!success) {
        rawSocket?.closeQuietly()
      }
    }
  }

  override fun connectTlsEtc(): ConnectResult {

            task.run();
          } catch (Exception e) { // sneaky checked exception
            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {
        // Ensure that if the thread was interrupted at all while processing the task queue, it
        // is returned to the delegate Executor interrupted so that it may handle the

            task.run();
          } catch (Exception e) { // sneaky checked exception
            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {
        // Ensure that if the thread was interrupted at all while processing the task queue, it
        // is returned to the delegate Executor interrupted so that it may handle the

    public void test_sitemaps_threadLocal() throws Exception {
        final String[] thread1Sitemaps = new String[] { "http://thread1.com/sitemap.xml" };
        final String[] thread2Sitemaps = new String[] { "http://thread2.com/sitemap.xml" };
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(2);
        final AtomicInteger successCount = new AtomicInteger(0);

            response = httpx.get("http://localhost:8000/docs")
        except httpx.ConnectError:
            time.sleep(1)
            break
    with sync_playwright() as playwright:
        run(playwright)
finally:

            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw thrown
          }
        } finally {
          currentThread.name = oldName
        }
      }
    }

  internal fun kickCoordinator(taskQueue: TaskQueue) {
    assertLockHeld()

    if (taskQueue.activeTask == null) {

    }

    val startedTask = startNextTask()
    val otherTasksStarted = startedTask != yieldCompleteTask

    try {
      while (currentTask != self) {
        taskRunner.wait()
      }
    } finally {
      serialTaskQueue.remove(yieldCompleteTask)
    }

    // If we're yielding until we're exhausted and a task run, keep going until a task doesn't run.

                    .loadCoreExtensions(mer, providedArtifacts, extensions));
        } finally {
            if (settingsCleaner != null) {
                settingsCleaner.run();
            }
            try {
                container.dispose();
            } finally {
                Thread.currentThread().setContextClassLoader(oldCL);
            }
        }
    }