* @param timeoutUnit with timeoutDuration, the maximum length of time to wait
   * @return the result returned by the Callable
   * @throws TimeoutException if the time limit is reached
   * @throws InterruptedException if the current thread was interrupted during execution
   * @throws ExecutionException if {@code callable} throws a checked exception
   * @throws UncheckedExecutionException if {@code callable} throws a {@code RuntimeException}

                                return "success";
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        });
                        successCount.incrementAndGet();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();

    return delegate.isDone();
  }

  @Override
  @ParametricNullness
  public V get() throws InterruptedException, ExecutionException {
    return delegate.get();
  }

  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    return delegate.get(timeout, unit);
  }

  @Override

    }
    throw e;
  }

  @Override
  public V get() throws ExecutionException, InterruptedException {
    try {
      super.get();
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    try {
      super.get(timeout, unit);

      () -> {
        try {
          MILLISECONDS.sleep(DELAY_MS);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      };
  private static final Runnable BAD_RUNNABLE =
      () -> {
        try {
          MILLISECONDS.sleep(DELAY_MS);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
        throw new SampleRuntimeException();

    }
    throw e;
  }

  @Override
  public V get() throws ExecutionException, InterruptedException {
    try {
      super.get();
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    try {
      super.get(timeout, unit);

  }

  @AndroidIncompatible // Bug? expected:<1> but was:<2>
  public void testConcurrentLoading() throws InterruptedException {
    testConcurrentLoading(CacheBuilder.newBuilder());
  }

  private static void testConcurrentLoading(CacheBuilder<Object, Object> builder)
      throws InterruptedException {
    testConcurrentLoadingDefault(builder);
    testConcurrentLoadingNull(builder);

  public void testAddDelayedShutdownHook_interrupted() throws InterruptedException {
    TestApplication application = new TestApplication();
    ExecutorService service = mock(ExecutorService.class);
    application.addDelayedShutdownHook(service, 2, SECONDS);
    when(service.awaitTermination(2, SECONDS)).thenThrow(new InterruptedException());
    application.shutdown();
    verify(service).shutdown();
  }

        assertEquals(2, seq2);
        assertEquals(3, seq3);
        assertTrue(seq2 > seq1);
        assertTrue(seq3 > seq2);
    }

    @Test
    void testHeartbeatUpdate() throws InterruptedException {
        long initialTime = registration.getLastHeartbeat();

        Thread.sleep(50); // Ensure sufficient time difference
        registration.updateHeartbeat();

import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.assertThrows;

@Deprecated
class SimplexTransferListenerTest {
    @Test
    void cancellation() throws InterruptedException {
        TransferListener delegate = new TransferListener() {
            @Override
            public void transferInitiated(TransferEvent event) throws TransferCancelledException {