AtomicBoolean interruptedExceptionThrown = new AtomicBoolean();
    CountDownLatch enterLatch = new CountDownLatch(1);
    CountDownLatch exitLatch = new CountDownLatch(1);
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            () -> {
              enterLatch.countDown();
              try {
                new CountDownLatch(1).await(); // wait forever
                throw new AssertionError();

    @Test
    public void test_concurrentSearcherRegistration() throws Exception {
        final int numThreads = 10;
        final int searchersPerThread = 5;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(numThreads);
        final AtomicInteger registeredCount = new AtomicInteger(0);

        try (RankFusionProcessor processor = new RankFusionProcessor()) {

        void testConcurrentReceived() throws InterruptedException {
            int threadCount = 10;
            CountDownLatch startLatch = new CountDownLatch(1);
            CountDownLatch endLatch = new CountDownLatch(threadCount);

            for (int i = 0; i < threadCount; i++) {
                new Thread(() -> {
                    try {

    static final Set<FinalizableReference> references = newConcurrentHashSet();

    static void register(Object referent, CountDownLatch latch) {
      references.add(new FinalizableReference(referent, latch));
    }

    final CountDownLatch latch;

    FinalizableReference(Object referent, CountDownLatch latch) {
      super(referent, referenceQueue);
      this.latch = latch;
    }

    @Override

  // Regression test for a deadlock where a task could be stuck busy waiting for the task to
  // transition to DONE
  public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);
    SettableFuture<String> taskResult = SettableFuture.create();
    InterruptibleTask<String> task =
        new InterruptibleTask<String>() {
          @Override

  // Regression test for a deadlock where a task could be stuck busy waiting for the task to
  // transition to DONE
  public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);
    SettableFuture<String> taskResult = SettableFuture.create();
    InterruptibleTask<String> task =
        new InterruptibleTask<String>() {
          @Override

    assertTrue(successLatch.await(200, MILLISECONDS));

    latch.countDown();
  }

  public void testListenersNotifiedOnError() throws Exception {
    CountDownLatch successLatch = new CountDownLatch(1);
    CountDownLatch listenerLatch = new CountDownLatch(1);

    ExecutorService exec = newCachedThreadPool();

    future.addListener(listenerLatch::countDown, exec);

    new Thread(
            () -> {

@GwtIncompatible
@J2ktIncompatible
public class ListenableFutureTaskTest extends TestCase {

  private ExecutorService exec;

  private final CountDownLatch runLatch = new CountDownLatch(1);
  private final CountDownLatch taskLatch = new CountDownLatch(1);
  private final CountDownLatch listenerLatch = new CountDownLatch(1);

  private volatile boolean throwException = false;

  private final ListenableFutureTask<Integer> task =

  }

  private static class SingleCallListener implements Runnable {

    private boolean expectCall = false;
    private final CountDownLatch calledCountDown = new CountDownLatch(1);

    @Override
    public void run() {
      assertTrue("Listener called before it was expected", expectCall);
      assertFalse("Listener called more than once", wasCalled());

        setPrivateField(transport, "smb2", true);
        setPrivateField(transport, "negotiated", negotiateResponse);

        int threadCount = 10;
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch doneLatch = new CountDownLatch(threadCount);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        // Create test data
        byte[] testData = new byte[64];