urlQueueService.delete(sessionId);
        dataService.delete(sessionId);
        urlFilter.clear();
    }

    /**
     * Closes the crawler, releasing resources.
     * This method is called automatically when the crawler is used in a try-with-resources statement.
     */
    @Override
    public void close() {
        clientFactory.close();
    }

    /**

        public MonitorTarget(final JobLog jobLog) {
            this.jobLog = jobLog;
        }

        /**
         * Called when the timeout expires. Updates the job log if the job is still running.
         */
        @Override
        public void expired() {
            if (jobLog.getEndTime() == null) {
                jobLog.setLastUpdated(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());

     * @param jobProcess the JobProcess to destroy
     * @return exit code of the destroyed process, or -1 if the process was null or could not be destroyed
     */
    protected int destroyProcess(final String sessionId, final JobProcess jobProcess) {
        if (jobProcess != null) {
            final InputStreamThread ist = jobProcess.getInputStreamThread();
            try {
                ist.interrupt();

    for (Constructor<X> constructor : preferringStringsThenThrowables(constructors)) {
      X instance = newFromConstructor(constructor, cause);
      if (instance != null) {
        if (instance.getCause() == null) {
          instance.initCause(cause);
        }
        return instance;
      }
    }
    throw new IllegalArgumentException(

        assertEquals(1024L, mockBasicFileInfo.getSize());
        assertEquals(FileInformation.FILE_BASIC_INFO, mockBasicFileInfo.getFileInformationLevel());

        // Verify all methods were called
        verify(mockBasicFileInfo).getAttributes();
        verify(mockBasicFileInfo).getCreateTime();
        verify(mockBasicFileInfo).getLastWriteTime();
        verify(mockBasicFileInfo).getLastAccessTime();

    WeakReference<Object> ref = new WeakReference<>(null);
    int expectedComputations = 0;
    for (int i = 0; i < iterations; i++) {
      // The entry should get garbage collected and recomputed.
      Object oldValue = ref.get();
      if (oldValue == null) {
        expectedComputations++;
      }
      ref = new WeakReference<>(cache.getUnchecked(1));
      oldValue = null;
      Thread.sleep(i);
      System.gc();

    @Override
    public ImmutableSetMultimap<K, V> build() {
      if (builderMap == null) {
        return ImmutableSetMultimap.of();
      }
      Collection<Map.Entry<K, ImmutableCollection.Builder<V>>> mapEntries = builderMap.entrySet();
      if (keyComparator != null) {
        mapEntries = Ordering.from(keyComparator).<K>onKeys().immutableSortedCopy(mapEntries);
      }

   *
   * @param element the element to add one occurrence of; may be null only if explicitly allowed by
   *     the implementation
   * @return {@code true} always, since this call is required to modify the multiset, unlike other
   *     {@link Collection} types
   * @throws NullPointerException if {@code element} is null and this implementation does not permit
   *     null elements

   */
  @get:Synchronized
  @set:Synchronized
  var idleCallback: Runnable? = null

  private var executorServiceOrNull: ExecutorService? = null

  @get:JvmName("executorService")
  @get:Synchronized
  val executorService: ExecutorService
    get() {
      if (executorServiceOrNull == null) {
        executorServiceOrNull =
          ThreadPoolExecutor(
            0,
            Int.MAX_VALUE,

   *
   * @param c the character to escape if necessary
   * @return the replacement characters, or {@code null} if no escaping was needed
   */
  protected abstract char @Nullable [] escape(char c);

  /**
   * Returns the escaped form of a given literal string, starting at the given index. This method is
   * called by the {@link #escape(String)} method when it discovers that escaping is required. It is