Service.super.awaitRunning(timeout);
  }

  @Override
  public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException {
    if (monitor.enterWhenUninterruptibly(hasReachedRunning, timeout, unit)) {
      try {
        checkCurrentState(RUNNING);
      } finally {
        monitor.leave();
      }
    } else {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.pager;

import java.util.ArrayList;
import java.util.List;

import org.codelibs.fess.unit.UnitFessTestCase;

public class DataConfigPagerTest extends UnitFessTestCase {

    public void test_DataConfigPager() {
        DataConfigPager dataconfigpager = new DataConfigPager();

 */
package org.codelibs.fess.entity;

import java.util.HashSet;
import java.util.Set;

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.unit.UnitFessTestCase;
import org.codelibs.fess.util.ComponentUtil;

public class PingResponseTest extends UnitFessTestCase {

    private FessConfig originalConfig;

    @Override

abstract class PublishRelease(
    prepTask: String,
    promoteTask: String,
    requiredConfirmationCode: String,
    promotedBranch: String,
    init: PublishRelease.() -> Unit = {},
) : PublishGradleDistributionFullBuild(
        promotedBranch = promotedBranch,
        prepTask = prepTask,
        promoteTask = promoteTask,
        triggerName = "ReadyforRelease",

      name = "NULL",
      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 5L,
      codec =
        object : BasicDerAdapter.Codec<Unit?> {
          override fun decode(reader: DerReader): Unit? = null

          override fun encode(
            writer: DerWriter,
            value: Unit?,
          ) {
          }
        },
    )

  val OBJECT_IDENTIFIER =
    BasicDerAdapter(

        setupMockComponents();
        searchLogHelper.init();
    }

    private void setupMockComponents() {
        ComponentUtil.setFessConfig(new MockFessConfig());
        ComponentUtil.register(new MockSystemHelper(), "systemHelper");
    }

    public void test_init() {
        SearchLogHelper helper = new SearchLogHelper();
        helper.init();

        assertNotNull(helper.userInfoCache);

  @Override
  @ParametricNullness
  public V get() {
    return value;
  }

  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit) throws ExecutionException {
    checkNotNull(unit);
    return get();
  }

  @Override
  public boolean isCancelled() {
    return false;
  }

  @Override
  public boolean isDone() {
    return true;
  }

   * GS, then RS, and US is least inclusive. (The content and length of a File, Group, Record, or
   * Unit are not specified.)
   *
   * @since 8.0
   */
  public static final byte RS = 30;

  /**
   * Unit Separator: These four information separators may be used within data in optional fashion,
   * except that their hierarchical relationship shall be: FS is the most inclusive, then GS, then

    3 -> UTF_16LE
    4 -> UTF_32BE
    -1 -> default
    else -> throw AssertionError()
  }

internal fun checkDuration(
  name: String,
  duration: Long,
  unit: TimeUnit,
): Int {
  check(duration >= 0L) { "$name < 0" }
  val millis = unit.toMillis(duration)
  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

  public boolean isTerminated() {
    synchronized (lock) {
      return shutdown && runningTasks == 0;
    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;