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()) {

       */
      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;
            }

        try {
            if (value.getClass() == String.class) {
                return converter.getAsObject((String) value);
            }
            return converter.getAsString(value);
        } catch (final Throwable cause) {
            throw new ConverterRuntimeException(destPropertyName, value, cause);
        }
    }

    /**
     * Finds the converter corresponding to the class.
     *
     * @param clazz

        when(handle.getFileId()).thenReturn(new byte[16]);
        when(tree.send(any(CommonServerMessageBlockRequest.class), any(), any(), any()))
                .thenThrow(new SmbException(0xC0000120, (Throwable) null));
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        List<FileNotifyInformation> result = sut.watch();

        assertNull(result, "Cancelled watch should return null");

       */
      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;

   */
  public <X extends Throwable> ClosingFuture<V> catching(
      Class<X> exceptionType, ClosingFunction<? super X, ? extends V> fallback, Executor executor) {
    return catchingMoreGeneric(exceptionType, fallback, executor);
  }

  // Avoids generic type capture inconsistency problems where |? extends V| is incompatible with V.
  private <X extends Throwable, W extends V> ClosingFuture<V> catchingMoreGeneric(

     *
     * @param success A callback for successful indexing.
     * @param error   A callback for indexing errors.
     */
    public void indexFromDocuments(final Consumer<Boolean> success, final Consumer<Throwable> error) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final long interval = fessConfig.getSuggestUpdateRequestIntervalAsInteger().longValue();