*     IOException}.
   */
  public static void close(@CheckForNull Closeable closeable, boolean swallowIOException)
      throws IOException {
    if (closeable == null) {
      return;
    }
    try {
      closeable.close();
    } catch (IOException e) {
      if (swallowIOException) {
        logger.log(Level.WARNING, "IOException thrown while closing Closeable.", e);
      } else {
        throw e;
      }
    }
  }

              @Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    FluentFuture<Closeable> unused = closingFuture.finishToFuture();
    assertThrows(
        IllegalStateException.class,
        () -> {

    }
  }

  private void doClose(Closeable closeable, boolean swallowException) throws IOException {
    doClose(closeable, swallowException, !swallowException);
  }

  // Close the closeable using the Closeables, passing in the swallowException
  // parameter. expectThrown determines whether we expect an exception to
  // be thrown by Closeables.close;
  private void doClose(Closeable closeable, boolean swallowException, boolean expectThrown)

    }
  }

  private void doClose(Closeable closeable, boolean swallowException) throws IOException {
    doClose(closeable, swallowException, !swallowException);
  }

  // Close the closeable using the Closeables, passing in the swallowException
  // parameter. expectThrown determines whether we expect an exception to
  // be thrown by Closeables.close;
  private void doClose(Closeable closeable, boolean swallowException, boolean expectThrown)

              @Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    FluentFuture<Closeable> unused = closingFuture.finishToFuture();
    assertThrows(
        IllegalStateException.class,
        () -> {

     * {@link #close(Closeable)}でも 例外が発生する可能性があります。その場合に{@literal finally}
     * ブロックから例外をスローすると、 {@literal try}ブロックで発生した元の例外が失われてしまいます。
     * </p>
     *
     * @param closeable
     *            クローズ可能なオブジェクト
     * @see Closeable#close()
     */
    public static void close(final Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {

    ClosingFuture<Closeable> closingFuture =
        ClosingFuture.submit(
            new ClosingCallable<Closeable>() {
              @Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    FluentFuture<Closeable> unused = closingFuture.finishToFuture();

    ClosingFuture<Closeable> closingFuture =
        ClosingFuture.submit(
            new ClosingCallable<Closeable>() {
              @Override
              public Closeable call(DeferredCloser closer) throws Exception {
                return closer.eventuallyClose(mockCloseable, executor);
              }
            },
            executor);
    FluentFuture<Closeable> unused = closingFuture.finishToFuture();

        }
    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

import static org.junit.Assert.assertThrows;

import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.io.Writer;

/**
 * Unit test for {@link AppendableWriter}.
 *
 * @author Alan Green
 */
public class AppendableWriterTest extends IoTestCase {

  /** Helper class for testing behavior with Flushable and Closeable targets. */