*/
    protected void executeCrawler() {
        final List<String> cmdList = new ArrayList<>();
        final String cpSeparator = SystemUtils.IS_OS_WINDOWS ? ";" : ":";
        final ServletContext servletContext = ComponentUtil.getComponent(ServletContext.class);
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final ProcessHelper processHelper = ComponentUtil.getProcessHelper();

      implements Serializable {
    private static final long serialVersionUID = 3;

    final Strength keyStrength;
    final Strength valueStrength;
    final Equivalence<Object> keyEquivalence;
    final Equivalence<Object> valueEquivalence;
    final int concurrencyLevel;

    transient ConcurrentMap<K, V> delegate;

    AbstractSerializationProxy(

  }

  private static final class DoNothingRunnable implements Runnable {
    @Override
    public void run() {}
  }

  // The thread executing the task publishes itself to the superclass' reference and the thread
  // interrupting sets DONE when it has finished interrupting.
  private static final Runnable DONE = new DoNothingRunnable();
  private static final Runnable PARKED = new DoNothingRunnable();

     * @param form The create form.
     * @return The bad word.
     */
    public static OptionalEntity<BadWord> getBadWord(final CreateForm form) {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final String username = systemHelper.getUsername();
        final long currentTime = systemHelper.getCurrentTimeAsLong();
        return getEntity(form, username, currentTime).map(entity -> {

     * @param in the input stream to read the mapping data from
     */
    protected void reload(final MappingUpdater updater, final InputStream in) {
        final Pattern parsePattern = Pattern.compile("(.*)\\s*=>\\s*(.*)\\s*$");
        final List<CharMappingItem> itemList = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, Constants.UTF_8))) {

                        Thread.yield();
                    }
                } catch (Exception e) {
                    exceptions.add(e);
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // Start all threads simultaneously
        startLatch.countDown();

        // Wait for completion

    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;

        } 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);

        final ClassLoader context = Thread.currentThread().getContextClassLoader();
        try {
            final ClassLoader cl = new URLClassLoader(new URL[0], getClass().getClassLoader());
            Thread.currentThread().setContextClassLoader(cl);
            assertThat(ClassLoaderUtil.getClassLoader(TestCase.class), is(sameInstance(cl)));
        } finally {

        final StringBuilder resultBuf = new StringBuilder();

        final PingResponse ping = searchEngineClient.ping();
        final int status = ping.getStatus();
        if (systemHelper.isChangedClusterState(status)) {
            if (fessConfig.hasNotification()) {
                final String toStrs = fessConfig.getNotificationTo();
                final String[] toAddresses;