protected Scroll scrollForDelete = new Scroll(TimeValue.timeValueMinutes(1));

    protected int sizeForDelete = 10;

    protected long retryInterval = 3 * 1000L;

    protected int maxRetryCount = 5;

    protected long connTimeout = 180 * 1000L;

    protected String searchPreference;

    protected String[] targetIndices;

    public FesenClient() {

    server.webSocket!!.close(1000, "Hello!")
    client.processNextFrame()
    client.listener.assertClosing(1000, "Hello!")
    assertThat(client.webSocket!!.close(1000, "Bye!")).isTrue()
    client.webSocket!!.finishReader()
    taskFaker.runTasks()
    client.listener.assertClosed(1000, "Hello!")
    server.processNextFrame()
    server.listener.assertClosing(1000, "Bye!")
    server.webSocket!!.finishReader()

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

    protected List<String> commandList;

    protected long commandTimeout = 30 * 1000L;// 30sec

    protected long commandDestroyTimeout = 5 * 1000L;// 5sec

    protected File baseDir;

    private Timer destoryTimer;

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {

package org.codelibs.fess.helper;

import org.codelibs.core.concurrent.CommonPoolUtil;
import org.codelibs.core.lang.ThreadUtil;

public abstract class AbstractConfigHelper {

    protected long reloadInterval = 1000L;

    public void update() {
        CommonPoolUtil.execute(this::load);
    }

    protected void waitForNext() {
        if (reloadInterval > 0) {
            ThreadUtil.sleep(reloadInterval);
        }

    protected long delayMillisAfterProcessing = 0L;

    protected long delayMillisAtNoUrlInQueue = 500L;

    protected long delayMillisBeforeProcessing = 0L;

    protected long delayMillisForWaitingNewUrl = 1000L;

    public DefaultIntervalController() {
    }

    public DefaultIntervalController(final Map<String, Long> params) {
        Long millis = params.get("delayMillisAfterProcessing");
        if (millis != null) {

import org.codelibs.fess.util.ComponentUtil;

public class PurgeThumbnailJob {
    private static final Logger logger = LogManager.getLogger(PurgeThumbnailJob.class);

    private long expiry = 30 * 24 * 60 * 60 * 1000L;

    public String execute() {
        try {
            final long count = ComponentUtil.getThumbnailManager().purge(getExpiry());
            return "Deleted " + count + " thumbnail files.";

            if (logger.isDebugEnabled()) {
                logger.debug("Interrupt {}", runningThread);
            }
            runningThread.interrupt();
            ThreadUtil.sleepQuietly(1000L);
            count++;
        }
    }

    public void stop() {
        running.set(false);
    }

        assertEquals("0bytes", MemoryUtil.byteCountToDisplaySize(0L));
        assertEquals("999bytes", MemoryUtil.byteCountToDisplaySize(999L));
        assertEquals("1000bytes", MemoryUtil.byteCountToDisplaySize(1000L));
        assertEquals("1.024KB", MemoryUtil.byteCountToDisplaySize(FileUtils.ONE_KB));
        assertEquals("999.999KB", MemoryUtil.byteCountToDisplaySize(999_999L));

    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos
    val elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos)
    assertThat(elapsedMillis).isBetween(500L, 1000L)
  }

  /**
   * Throttle the response body by sleeping 500ms after every 3 bytes. With a 6-byte response, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test

    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos
    val elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos)
    assertThat(elapsedMillis).isBetween(500L, 1000L)
  }

  /**
   * Throttle the response body by sleeping 500ms after every 3 bytes. With a 6-byte response, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test