} 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);
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

    } 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);
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

        } catch (Exception e) {
            // ant failed, so see if we have buffered output to emit, then rethrow the failure
            String buffer = outputBuffer.toString()
            if (buffer.isEmpty() == false) {
                logger.error("=== Ant output ===\n${buffer}")
            }
            throw e
        }
    }

    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    try {
      future.get();
      fail("Future should rethrow the exception.");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().hasMessageThat().isEqualTo(message);
    }
  }

  private Flushables() {}

  /**
   * Flush a {@link Flushable}, with control over whether an {@code IOException} may be thrown.
   *
   * <p>If {@code swallowIOException} is true, then we don't rethrow {@code IOException}, but merely
   * log it.
   *
   * @param flushable the {@code Flushable} object to be flushed.
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code flush}

    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    try {
      future.get();
      fail("Future should rethrow the exception.");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().hasMessageThat().isEqualTo(message);
    }
  }

                    new ProjectExecutionEvent(session, currentProject, t));

            // rethrow original errors and runtime exceptions
            if (t instanceof RuntimeException runtimeException) {
                throw runtimeException;
            }
            if (t instanceof Error error) {
                throw error;
            }
        } finally {
            session.setCurrentProject(null);

   *   try {
   *     // ... code which does something with the stream ...
   *     threw = false;
   *   } finally {
   *     // If an exception occurs, rethrow it only if threw==false:
   *     Closeables.close(stream, threw);
   *   }
   * }
   * }
   *
   * @param closeable the {@code Closeable} object to be closed, or null, in which case this method
   *     does nothing

  }

  // Set up a flushable to expect to be flushed, and optionally to
  // throw an exception.
  private void setupFlushable(boolean shouldThrowOnFlush) throws IOException {
    mockFlushable = mock(Flushable.class);
    if (shouldThrowOnFlush) {
      doThrow(new IOException("This should only appear in the logs. It should not be rethrown."))
          .when(mockFlushable)
          .flush();
    }
  }

  }

  // Set up a flushable to expect to be flushed, and optionally to
  // throw an exception.
  private void setupFlushable(boolean shouldThrowOnFlush) throws IOException {
    mockFlushable = mock(Flushable.class);
    if (shouldThrowOnFlush) {
      doThrow(new IOException("This should only appear in the logs. It should not be rethrown."))
          .when(mockFlushable)
          .flush();
    }
  }