android-14.0.0_r21/search

/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.jimfs;

import static com.google.common.jimfs.TestUtils.assertNotEquals;
import static com.google.common.jimfs.TestUtils.buffer;
import static com.google.common.jimfs.TestUtils.bytes;
import static com.google.common.jimfs.TestUtils.regularFile;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.nio.file.StandardOpenOption.APPEND;
import static java.nio.file.StandardOpenOption.READ;
import static java.nio.file.StandardOpenOption.WRITE;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import com.google.common.collect.ImmutableSet;
import com.google.common.testing.NullPointerTester;
import com.google.common.util.concurrent.Runnables;
import com.google.common.util.concurrent.SettableFuture;
import com.google.common.util.concurrent.Uninterruptibles;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousCloseException;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.FileLockInterruptionException;
import java.nio.channels.NonReadableChannelException;
import java.nio.channels.NonWritableChannelException;
import java.nio.file.OpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Most of the behavior of {@link JimfsFileChannel} is handled by the {@link RegularFile}
 * implementations, so the thorough tests of that are in {@link RegularFileTest}. This mostly tests
 * interactions with the file and channel positions.
 *
 * @author Colin Decker
 */
@RunWith(JUnit4.class)
public class JimfsFileChannelTest {

  private static FileChannel channel(RegularFile file, OpenOption... options) throws IOException {
    return new JimfsFileChannel(
        file,
        Options.getOptionsForChannel(ImmutableSet.copyOf(options)),
        new FileSystemState(Runnables.doNothing()));
  }

  @Test
  public void testPosition() throws IOException {
    FileChannel channel = channel(regularFile(10), READ);
    assertEquals(0, channel.position());
    assertSame(channel, channel.position(100));
    assertEquals(100, channel.position());
  }

  @Test
  public void testSize() throws IOException {
    RegularFile file = regularFile(10);
    FileChannel channel = channel(file, READ);

    assertEquals(10, channel.size());

    file.write(10, new byte[90], 0, 90);
    assertEquals(100, channel.size());
  }

  @Test
  public void testRead() throws IOException {
    RegularFile file = regularFile(20);
    FileChannel channel = channel(file, READ);
    assertEquals(0, channel.position());

    ByteBuffer buf = buffer("1234567890");
    ByteBuffer buf2 = buffer("123457890");
    assertEquals(10, channel.read(buf));
    assertEquals(10, channel.position());

    buf.flip();
    assertEquals(10, channel.read(new ByteBuffer[] {buf, buf2}));
    assertEquals(20, channel.position());

    buf.flip();
    buf2.flip();
    file.write(20, new byte[10], 0, 10);
    assertEquals(10, channel.read(new ByteBuffer[] {buf, buf2}, 0, 2));
    assertEquals(30, channel.position());

    buf.flip();
    assertEquals(10, channel.read(buf, 5));
    assertEquals(30, channel.position());

    buf.flip();
    assertEquals(-1, channel.read(buf));
    assertEquals(30, channel.position());
  }

  @Test
  public void testWrite() throws IOException {
    RegularFile file = regularFile(0);
    FileChannel channel = channel(file, WRITE);
    assertEquals(0, channel.position());

    ByteBuffer buf = buffer("1234567890");
    ByteBuffer buf2 = buffer("1234567890");
    assertEquals(10, channel.write(buf));
    assertEquals(10, channel.position());

    buf.flip();
    assertEquals(20, channel.write(new ByteBuffer[] {buf, buf2}));
    assertEquals(30, channel.position());

    buf.flip();
    buf2.flip();
    assertEquals(20, channel.write(new ByteBuffer[] {buf, buf2}, 0, 2));
    assertEquals(50, channel.position());

    buf.flip();
    assertEquals(10, channel.write(buf, 5));
    assertEquals(50, channel.position());
  }

  @Test
  public void testAppend() throws IOException {
    RegularFile file = regularFile(0);
    FileChannel channel = channel(file, WRITE, APPEND);
    assertEquals(0, channel.position());

    ByteBuffer buf = buffer("1234567890");
    ByteBuffer buf2 = buffer("1234567890");

    assertEquals(10, channel.write(buf));
    assertEquals(10, channel.position());

    buf.flip();
    channel.position(0);
    assertEquals(20, channel.write(new ByteBuffer[] {buf, buf2}));
    assertEquals(30, channel.position());

    buf.flip();
    buf2.flip();
    channel.position(0);
    assertEquals(20, channel.write(new ByteBuffer[] {buf, buf2}, 0, 2));
    assertEquals(50, channel.position());

    buf.flip();
    channel.position(0);
    assertEquals(10, channel.write(buf, 5));
    assertEquals(60, channel.position());

    buf.flip();
    channel.position(0);
    assertEquals(10, channel.transferFrom(new ByteBufferChannel(buf), 0, 10));
    assertEquals(70, channel.position());
  }

  @Test
  public void testTransferTo() throws IOException {
    RegularFile file = regularFile(10);
    FileChannel channel = channel(file, READ);

    ByteBufferChannel writeChannel = new ByteBufferChannel(buffer("1234567890"));
    assertEquals(10, channel.transferTo(0, 100, writeChannel));
    assertEquals(0, channel.position());
  }

  @Test
  public void testTransferFrom() throws IOException {
    RegularFile file = regularFile(0);
    FileChannel channel = channel(file, WRITE);

    ByteBufferChannel readChannel = new ByteBufferChannel(buffer("1234567890"));
    assertEquals(10, channel.transferFrom(readChannel, 0, 100));
    assertEquals(0, channel.position());
  }

  @Test
  public void testTruncate() throws IOException {
    RegularFile file = regularFile(10);
    FileChannel channel = channel(file, WRITE);

    channel.truncate(10); // no resize, >= size
    assertEquals(10, file.size());
    channel.truncate(11); // no resize, > size
    assertEquals(10, file.size());
    channel.truncate(5); // resize down to 5
    assertEquals(5, file.size());

    channel.position(20);
    channel.truncate(10);
    assertEquals(10, channel.position());
    channel.truncate(2);
    assertEquals(2, channel.position());
  }

  @Test
  public void testFileTimeUpdates() throws IOException {
    RegularFile file = regularFile(10);
    FileChannel channel =
        new JimfsFileChannel(
            file,
            ImmutableSet.<OpenOption>of(READ, WRITE),
            new FileSystemState(Runnables.doNothing()));

    // accessed
    long accessTime = file.getLastAccessTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.read(ByteBuffer.allocate(10));
    assertNotEquals(accessTime, file.getLastAccessTime());

    accessTime = file.getLastAccessTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.read(ByteBuffer.allocate(10), 0);
    assertNotEquals(accessTime, file.getLastAccessTime());

    accessTime = file.getLastAccessTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.read(new ByteBuffer[] {ByteBuffer.allocate(10)});
    assertNotEquals(accessTime, file.getLastAccessTime());

    accessTime = file.getLastAccessTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.read(new ByteBuffer[] {ByteBuffer.allocate(10)}, 0, 1);
    assertNotEquals(accessTime, file.getLastAccessTime());

    accessTime = file.getLastAccessTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.transferTo(0, 10, new ByteBufferChannel(10));
    assertNotEquals(accessTime, file.getLastAccessTime());

    // modified
    long modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.write(ByteBuffer.allocate(10));
    assertNotEquals(modifiedTime, file.getLastModifiedTime());

    modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.write(ByteBuffer.allocate(10), 0);
    assertNotEquals(modifiedTime, file.getLastModifiedTime());

    modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.write(new ByteBuffer[] {ByteBuffer.allocate(10)});
    assertNotEquals(modifiedTime, file.getLastModifiedTime());

    modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.write(new ByteBuffer[] {ByteBuffer.allocate(10)}, 0, 1);
    assertNotEquals(modifiedTime, file.getLastModifiedTime());

    modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.truncate(0);
    assertNotEquals(modifiedTime, file.getLastModifiedTime());

    modifiedTime = file.getLastModifiedTime();
    Uninterruptibles.sleepUninterruptibly(2, MILLISECONDS);

    channel.transferFrom(new ByteBufferChannel(10), 0, 10);
    assertNotEquals(modifiedTime, file.getLastModifiedTime());
  }

  @Test
  public void testClose() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);
    ExecutorService executor = Executors.newSingleThreadExecutor();
    assertTrue(channel.isOpen());
    channel.close();
    assertFalse(channel.isOpen());

    try {
      channel.position();
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.position(0);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.lock();
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.lock(0, 10, true);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.tryLock();
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.tryLock(0, 10, true);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.force(true);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.write(buffer("111"));
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.write(buffer("111"), 10);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.write(new ByteBuffer[] {buffer("111"), buffer("111")});
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.write(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.transferFrom(new ByteBufferChannel(bytes("1111")), 0, 4);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.truncate(0);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.read(buffer("111"));
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.read(buffer("111"), 10);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.read(new ByteBuffer[] {buffer("111"), buffer("111")});
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.read(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2);
      fail();
    } catch (ClosedChannelException expected) {
    }

    try {
      channel.transferTo(0, 10, new ByteBufferChannel(buffer("111")));
      fail();
    } catch (ClosedChannelException expected) {
    }

    executor.shutdown();
  }

  @Test
  public void testWritesInReadOnlyMode() throws IOException {
    FileChannel channel = channel(regularFile(0), READ);

    try {
      channel.write(buffer("111"));
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.write(buffer("111"), 10);
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.write(new ByteBuffer[] {buffer("111"), buffer("111")});
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.write(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2);
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.transferFrom(new ByteBufferChannel(bytes("1111")), 0, 4);
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.truncate(0);
      fail();
    } catch (NonWritableChannelException expected) {
    }

    try {
      channel.lock(0, 10, false);
      fail();
    } catch (NonWritableChannelException expected) {
    }
  }

  @Test
  public void testReadsInWriteOnlyMode() throws IOException {
    FileChannel channel = channel(regularFile(0), WRITE);

    try {
      channel.read(buffer("111"));
      fail();
    } catch (NonReadableChannelException expected) {
    }

    try {
      channel.read(buffer("111"), 10);
      fail();
    } catch (NonReadableChannelException expected) {
    }

    try {
      channel.read(new ByteBuffer[] {buffer("111"), buffer("111")});
      fail();
    } catch (NonReadableChannelException expected) {
    }

    try {
      channel.read(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2);
      fail();
    } catch (NonReadableChannelException expected) {
    }

    try {
      channel.transferTo(0, 10, new ByteBufferChannel(buffer("111")));
      fail();
    } catch (NonReadableChannelException expected) {
    }

    try {
      channel.lock(0, 10, true);
      fail();
    } catch (NonReadableChannelException expected) {
    }
  }

  @Test
  public void testPositionNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.position(-1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  @Test
  public void testTruncateNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.truncate(-1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  @Test
  public void testWriteNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.write(buffer("111"), -1);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    ByteBuffer[] bufs = {buffer("111"), buffer("111")};
    try {
      channel.write(bufs, -1, 10);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      channel.write(bufs, 0, -1);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  @Test
  public void testReadNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.read(buffer("111"), -1);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    ByteBuffer[] bufs = {buffer("111"), buffer("111")};
    try {
      channel.read(bufs, -1, 10);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      channel.read(bufs, 0, -1);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  @Test
  public void testTransferToNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.transferTo(-1, 0, new ByteBufferChannel(10));
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      channel.transferTo(0, -1, new ByteBufferChannel(10));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  @Test
  public void testTransferFromNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.transferFrom(new ByteBufferChannel(10), -1, 0);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      channel.transferFrom(new ByteBufferChannel(10), 0, -1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  @Test
  public void testLockNegative() throws IOException {
    FileChannel channel = channel(regularFile(0), READ, WRITE);

    try {
      channel.lock(-1, 10, true);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      channel.lock(0, -1, true);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      channel.tryLock(-1, 10, true);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      channel.tryLock(0, -1, true);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  @Test
  public void testNullPointerExceptions() throws IOException {
    FileChannel channel = channel(regularFile(100), READ, WRITE);

    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicInstanceMethods(channel);
  }

  @Test
  public void testLock() throws IOException {
    FileChannel channel = channel(regularFile(10), READ, WRITE);

    assertNotNull(channel.lock());
    assertNotNull(channel.lock(0, 10, false));
    assertNotNull(channel.lock(0, 10, true));

    assertNotNull(channel.tryLock());
    assertNotNull(channel.tryLock(0, 10, false));
    assertNotNull(channel.tryLock(0, 10, true));

    FileLock lock = channel.lock();
    assertTrue(lock.isValid());
    lock.release();
    assertFalse(lock.isValid());
  }

  @Test
  public void testAsynchronousClose() throws Exception {
    RegularFile file = regularFile(10);
    final FileChannel channel = channel(file, READ, WRITE);

    file.writeLock().lock(); // ensure all operations on the channel will block

    ExecutorService executor = Executors.newCachedThreadPool();

    CountDownLatch latch = new CountDownLatch(BLOCKING_OP_COUNT);
    List<Future<?>> futures = queueAllBlockingOperations(channel, executor, latch);

    // wait for all the threads to have started running
    latch.await();
    // then ensure time for operations to start blocking
    Uninterruptibles.sleepUninterruptibly(20, MILLISECONDS);

    // close channel on this thread
    channel.close();

    // the blocking operations are running on different threads, so they all get
    // AsynchronousCloseException
    for (Future<?> future : futures) {
      try {
        future.get();
        fail();
      } catch (ExecutionException expected) {
        assertWithMessage("blocking thread exception")
            .that(expected.getCause())
            .isInstanceOf(AsynchronousCloseException.class);
      }
    }
  }

  @Test
  public void testCloseByInterrupt() throws Exception {
    RegularFile file = regularFile(10);
    final FileChannel channel = channel(file, READ, WRITE);

    file.writeLock().lock(); // ensure all operations on the channel will block

    ExecutorService executor = Executors.newCachedThreadPool();

    final CountDownLatch threadStartLatch = new CountDownLatch(1);
    final SettableFuture<Throwable> interruptException = SettableFuture.create();

    // This thread, being the first to run, will be blocking on the interruptible lock (the byte
    // file's write lock) and as such will be interrupted properly... the other threads will be
    // blocked on the lock that guards the position field and the specification that only one method
    // on the channel will be in progress at a time. That lock is not interruptible, so we must
    // interrupt this thread.
    Thread thread =
        new Thread(
            new Runnable() {
              @Override
              public void run() {
                threadStartLatch.countDown();
                try {
                  channel.write(ByteBuffer.allocate(20));
                  interruptException.set(null);
                } catch (Throwable e) {
                  interruptException.set(e);
                }
              }
            });
    thread.start();

    // let the thread start running
    threadStartLatch.await();
    // then ensure time for thread to start blocking on the write lock
    Uninterruptibles.sleepUninterruptibly(10, MILLISECONDS);

    CountDownLatch blockingStartLatch = new CountDownLatch(BLOCKING_OP_COUNT);
    List<Future<?>> futures = queueAllBlockingOperations(channel, executor, blockingStartLatch);

    // wait for all blocking threads to start
    blockingStartLatch.await();
    // then ensure time for the operations to start blocking
    Uninterruptibles.sleepUninterruptibly(20, MILLISECONDS);

    // interrupting this blocking thread closes the channel and makes all the other threads
    // throw AsynchronousCloseException... the operation on this thread should throw
    // ClosedByInterruptException
    thread.interrupt();

    // get the exception that caused the interrupted operation to terminate
    assertWithMessage("interrupted thread exception")
        .that(interruptException.get(200, MILLISECONDS))
        .isInstanceOf(ClosedByInterruptException.class);

    // check that each other thread got AsynchronousCloseException (since the interrupt, on a
    // different thread, closed the channel)
    for (Future<?> future : futures) {
      try {
        future.get();
        fail();
      } catch (ExecutionException expected) {
        assertWithMessage("blocking thread exception")
            .that(expected.getCause())
            .isInstanceOf(AsynchronousCloseException.class);
      }
    }
  }

  private static final int BLOCKING_OP_COUNT = 10;

  /**
   * Queues blocking operations on the channel in separate threads using the given executor. The
   * given latch should have a count of BLOCKING_OP_COUNT to allow the caller wants to wait for all
   * threads to start executing.
   */
  private List<Future<?>> queueAllBlockingOperations(
      final FileChannel channel, ExecutorService executor, final CountDownLatch startLatch) {
    List<Future<?>> futures = new ArrayList<>();

    final ByteBuffer buffer = ByteBuffer.allocate(10);
    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.write(buffer);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.write(buffer, 0);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.write(new ByteBuffer[] {buffer, buffer});
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.write(new ByteBuffer[] {buffer, buffer, buffer}, 0, 2);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.read(buffer);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.read(buffer, 0);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.read(new ByteBuffer[] {buffer, buffer});
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.read(new ByteBuffer[] {buffer, buffer, buffer}, 0, 2);
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.transferTo(0, 10, new ByteBufferChannel(buffer));
                return null;
              }
            }));

    futures.add(
        executor.submit(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                startLatch.countDown();
                channel.transferFrom(new ByteBufferChannel(buffer), 0, 10);
                return null;
              }
            }));

    return futures;
  }

  /**
   * Tests that the methods on the default FileChannel that support InterruptibleChannel behavior
   * also support it on JimfsFileChannel, by just interrupting the thread before calling the method.
   */
  @Test
  public void testInterruptedThreads() throws IOException {
    final ByteBuffer buf = ByteBuffer.allocate(10);
    final ByteBuffer[] bufArray = {buf};

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.size();
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.position();
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.position(0);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.write(buf);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.write(bufArray, 0, 1);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.read(buf);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.read(bufArray, 0, 1);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.write(buf, 0);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.read(buf, 0);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.transferTo(0, 1, channel(regularFile(10), READ, WRITE));
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.transferFrom(channel(regularFile(10), READ, WRITE), 0, 1);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.force(true);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.truncate(0);
          }
        });

    assertClosedByInterrupt(
        new FileChannelMethod() {
          @Override
          public void call(FileChannel channel) throws IOException {
            channel.lock(0, 1, true);
          }
        });

    // tryLock() does not handle interruption
    // map() always throws UOE; it doesn't make sense for it to try to handle interruption
  }

  private interface FileChannelMethod {
    void call(FileChannel channel) throws IOException;
  }

  /**
   * Asserts that when the given operation is run on an interrupted thread, {@code
   * ClosedByInterruptException} is thrown, the channel is closed and the thread is no longer
   * interrupted.
   */
  private static void assertClosedByInterrupt(FileChannelMethod method) throws IOException {
    FileChannel channel = channel(regularFile(10), READ, WRITE);
    Thread.currentThread().interrupt();
    try {
      method.call(channel);
      fail(
          "expected the method to throw ClosedByInterruptException or "
              + "FileLockInterruptionException");
    } catch (ClosedByInterruptException | FileLockInterruptionException expected) {
      assertFalse("expected the channel to be closed", channel.isOpen());
      assertTrue("expected the thread to still be interrupted", Thread.interrupted());
    } finally {
      Thread.interrupted(); // ensure the thread isn't interrupted when this method returns
    }
  }
}