private final List<Suppression> suppressions = new ArrayList<>();

    @Override
    public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
      suppressions.add(new Suppression(closeable, thrown, suppressed));
    }
  }

  /** Record of a call to suppress. */
  private static class Suppression {
    private final Closeable closeable;

      state.write(b, off, len);
    } finally {
      reachabilityFence(byteSource);
    }
  }

  @Override
  public void close() throws IOException {
    try {
      state.close();
    } finally {
      reachabilityFence(byteSource);
    }
  }

  @Override
  public void flush() throws IOException {
    try {
      state.flush();
    } finally {
      reachabilityFence(byteSource);

     */
    public static class FileInfo {
        private final String name;
        private final long size;
        private final long lastModified;
        private final boolean isDirectory;
        private final long attributes;
        private final long creationTime;
        private final long lastAccessTime;

        /**
         * Create file info from name and attributes
         *

        final NtlmPasswordAuthenticator correctAuth = new NtlmPasswordAuthenticator("domain", "user", new String(password));
        final NtlmPasswordAuthenticator wrongAuth = new NtlmPasswordAuthenticator("domain", "user", new String(wrongPassword));

        final int threadCount = 10;
        final int operationsPerThread = 100;

    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  /**
   * Invokes {@code latch.}{@link CountDownLatch#await(long, TimeUnit) await(timeout, unit)}

    }

    @Test
    public void test_execute_web() throws Exception {
        final CrawlerWebServer server = new CrawlerWebServer(0);
        server.start();

        final String url = "http://localhost:" + server.getPort() + "/";
        try {
            final int maxCount = 50;
            final int numOfThread = 10;

            final File file = File.createTempFile("crawler-", "");
            file.delete();

          assertThrows(RuntimeException.class, () -> GcFinalization.awaitClear(ref));
      assertWrapsInterruptedException(expected);
    } finally {
      reachabilityFence(foo);
      interruptenator.shutdown();
      Thread.interrupted();
    }
  }

  private static final class Foo {}

  public void testAwaitDone_finalizationPredicate_interrupted() {

    private static final Logger log = LoggerFactory.getLogger(SecureCredentialStorage.class);

    private static final String ENCRYPTION_ALGORITHM = "AES/GCM/NoPadding";
    private static final String KEY_ALGORITHM = "AES";
    private static final String KEY_DERIVATION_ALGORITHM = "PBKDF2WithHmacSHA256";
    private static final int KEY_SIZE = 256;
    private static final int GCM_TAG_SIZE = 128;

        return seq.length();
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    }
  }

  private static final class EmptyCharSource extends StringCharSource {

    private static final EmptyCharSource INSTANCE = new EmptyCharSource();

    private EmptyCharSource() {
      super("");
    }

    @Override

                interruptedExceptionThrown.set(true);
                throw e;
              } finally {
              }
            });
    assertFalse(task.isDone());
    Thread thread =
        new Thread(
            () -> {
              try {
                task.run();
              } finally {
                exitLatch.countDown();
              }
            });
    thread.start();