*/
@NullUnmarked
public class UninterruptiblesTest extends TestCase {
  private static final String EXPECTED_TAKE = "expectedTake";

  /** Timeout to use when we don't expect the timeout to expire. */
  private static final long LONG_DELAY_MS = 2500;

  private static final long SLEEP_SLACK = 2;

  private final TearDownStack tearDownStack = new TearDownStack();

      }

      synchronized(this) {
        this.bytes = publicSuffixListBytes!!
        this.exceptionBytes = publicSuffixExceptionListBytes!!
      }
    } finally {
      readCompleteLatch.countDown()
    }
  }

  abstract fun listSource(): Source

  override fun ensureLoaded() {
    if (!listRead.get() && listRead.compareAndSet(false, true)) {

        try {
          super.close()
        } finally {
          closedLatch.countDown()
        }
      }
    }.buffer()

  override val sink: BufferedSink =
    object : ForwardingSink(delegate.sink) {
      private var closed = false

      override fun close() {
        if (closed) return
        try {
          super.close()
        } finally {
          closedLatch.countDown()
        }
      }

        super();
    }

    private static final Logger logger = LogManager.getLogger(ScriptExecutorJob.class);

    @Override
    public void run(final LaJobRuntime runtime) {
        final JobHelper jobHelper = ComponentUtil.getJobHelper();
        try {
            jobHelper.setJobRuntime(runtime);
            process(runtime);
        } finally {
            jobHelper.setJobRuntime(null);
        }
    }

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

    /**
     *
     */
    private static final int SIGNATURE_OFFSET = 48;
    private static final int SIGNATURE_LENGTH = 16;
    private final Mac digest;
    private final ReentrantLock signingLock = new ReentrantLock();
    private byte[] signingKey;
    private final String algorithmName;

        } catch (AuthorizationException e) {
            throw new TransferFailedException("Authorization failed: " + e.getMessage(), e);
        } finally {
            // Remove remaining TransferListener instances (checksum handlers removed in above finally clause)
            if (downloadMonitor != null) {
                wagon.removeTransferListener(downloadMonitor);
            }

            disconnectWagon(wagon);

    private void importFessJson(final String fileName, final File tempFile) {
        try (final InputStream in = new FileInputStream(tempFile); final OutputStream out = Files.newOutputStream(getFessJsonPath())) {
            CopyUtil.copy(in, out);
        } catch (final IOException e) {
            logger.warn("Failed to process fess.json file: {}", fileName, e);
        } finally {
            deleteTempFile(tempFile);
        }
    }

     */
    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {
        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }

        final MimeTypeHelper mimeTypeHelper = getMimeTypeHelper();
        final ExtractorFactory extractorFactory = getExtractorFactory();
        final StringBuilder buf = new StringBuilder(1000);

      // skip may not be supported... at any rate, try reading
    } finally {
      closer.close();
    }

    closer = Closer.create();
    try {
      InputStream in = closer.register(openStream());
      return ByteStreams.exhaust(in);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

    assertTrue(future.isCancelled());
    delegateFuture = (ScheduledFuture<?>) delegateQueue.element();
    assertTrue(delegateFuture.isCancelled());
  }

  private static final class ThrowingRunnable implements Runnable {
    final int throwAfterCount;
    final RuntimeException thrown;
    int count;

    ThrowingRunnable(int throwAfterCount, RuntimeException thrown) {
      this.throwAfterCount = throwAfterCount;