return task.toString();
            }
          };
      queue.add(submittedTask);
      workerRunningState = QUEUING;
    }

    try {
      executor.execute(worker);
    } catch (Throwable t) {
      // Any Exception is either a RuntimeException or sneaky checked exception.
      synchronized (queue) {
        boolean removed =
            (workerRunningState == IDLE || workerRunningState == QUEUING)

            Trans2FindFirst2Response resp = inv.getArgument(1);
            resp.received(); // mark as received
            throw new SmbException(NtStatus.NT_STATUS_NO_SUCH_FILE, (Throwable) null);
        });

        DirFileEntryEnumIterator1 it = new DirFileEntryEnumIterator1(tree, parent, "*", null, 0);
        assertFalse(it.hasNext(), "Iterator should be empty when server reports no such file");

     *
     * @param se the SmbException to convert
     * @return the resulting IOException
     */
    protected IOException seToIoe(final SmbException se) {
        IOException ioe = se;
        Throwable root = se.getRootCause();
        if (root instanceof TransportException) {
            ioe = (TransportException) root;
            root = ((TransportException) ioe).getRootCause();
        }

        public void stop() {
            /* No-op */ }
    }

    private static class FastMockFailureUrlService extends FailureUrlService {
        public void store(DataConfig dataConfig, String errorName, String url, Throwable e) {
            /* No-op */ }
    }

    private static class FastMockSearchEngineClient extends SearchEngineClient {
        @Override
        public long deleteByQuery(String index, QueryBuilder queryBuilder) {

     * @param se the SmbException to convert
     * @return an IOException wrapping the SmbException
     */
    protected static IOException seToIoe(final SmbException se) {
        IOException ioe = se;
        Throwable root = se.getCause();
        if (root instanceof TransportException) {
            ioe = (TransportException) root;
            root = ioe.getCause();
        }
        if (root instanceof InterruptedException) {

            } else if (logger.isInfoEnabled()) {
                logger.info("Crawler is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {
            logger.error("Crawler does not work correctly.", t);
            exitCode = Constants.EXIT_FAIL;
        } finally {
            if (commandThread != null && commandThread.isAlive()) {

   * ATOMIC_HELPER. That initialization code may log after we assign to ATOMIC_HELPER.
   */

  private static final AtomicHelper ATOMIC_HELPER;

  static {
    AtomicHelper helper;
    Throwable thrownUnsafeFailure = null;
    Throwable thrownAtomicReferenceFieldUpdaterFailure = null;

    if (mightBeAndroid()) {
      try {
        helper = new UnsafeAtomicHelper();

        return ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)
            ? UnsafeByteArray.UNSAFE_LITTLE_ENDIAN
            : UnsafeByteArray.UNSAFE_BIG_ENDIAN;
      }
    } catch (Throwable t) {
      // ensure we really catch *everything*
    }

    return JavaLittleEndianBytes.INSTANCE;
  }

  // Compare AbstractFuture.VarHandleAtomicHelperMaker.

       */
      setException(e);
      return;
    }

    T transformResult;
    try {
      transformResult = doTransform(localFunction, sourceResult);
    } catch (Throwable t) {
      restoreInterruptIfIsInterruptedException(t);
      // This exception is irrelevant in this thread, but useful for the client.
      setException(t);
      return;
    } finally {
      function = null;

        assertArgumentNotNull("method", method);

        try {
            return (T) method.invoke(target, args);
        } catch (final InvocationTargetException ex) {
            final Throwable t = ex.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            }
            if (t instanceof Error) {
                throw (Error) t;
            }