break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }

  public void testFutureGetThrowsFunctionException() throws Exception {
    inputFuture.set(EXCEPTION_DATA);
    listener.assertException(EXCEPTION);
  }

  public void testFutureGetThrowsCancellationIfInputCancelled() throws Exception {
    inputFuture.cancel(true); // argument is ignored

    private Path tempDir;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        action = new AdminDesignAction();
        tempDir = Files.createTempDirectory("fess_test");
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        // Clean up temp directory
        if (tempDir != null) {

   * second value, and so on.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void writeMap(
      Map<K, V> map, ObjectOutputStream stream) throws IOException {
    stream.writeInt(map.size());
    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**

        throws InterruptedException {
      lastMethodCalled = "invokeAll";
      assertTaskWrapped(tasks);
      return inline.invokeAll(tasks);
    }

    @Override
    public <T> List<Future<T>> invokeAll(
        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
        throws InterruptedException {
      assertTaskWrapped(tasks);

  public void testNewReference() throws Exception {
    assertThat(Atomics.newReference().get()).isNull();
  }

  public void testNewReference_withInitialValue() throws Exception {
    assertThat(Atomics.newReference(null).get()).isNull();
    assertEquals(OBJECT, Atomics.newReference(OBJECT).get());
  }

  public void testNewReferenceArray_withLength() throws Exception {
    int length = 42;

     * @throws IllegalAccessRuntimeException {@link IllegalAccessException} if an error occurs
     * @see Field#getInt(Object)
     */
    public static int getInt(final Field field, final Object target) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        try {
            return field.getInt(target);
        } catch (final IllegalAccessException ex) {

  }

  private static final byte[] bytes = newPreFilledByteArray(10000);

  private TestByteSource source;

  @Override
  protected void setUp() throws Exception {
    source = new TestByteSource(bytes);
  }

  public void testOpenBufferedStream() throws IOException {
    InputStream in = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

    private static ASN1Sequence parseSequence(byte[] token) throws PACDecodingException {
        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos ApReq");

        return this.treeConnection.getSession();
    }

    @Override
    public void ensureDFSResolved() throws CIFSException {
        this.treeConnection.ensureDFSResolved(this.resourceLoc);
    }

    @Override
    public boolean hasCapability(final int cap) throws SmbException {
        return this.treeConnection.hasCapability(cap);
    }

    /**
     * {@inheritDoc}
     *

   *
   * <p>If this network is directed, the endpoints must be ordered.
   *
   * @throws IllegalArgumentException if there are multiple parallel edges connecting {@code nodeU}
   *     to {@code nodeV}
   * @throws IllegalArgumentException if either endpoint is not an element of this network
   * @throws IllegalArgumentException if the endpoints are unordered and the network is directed
   * @since 27.1
   */