ServiceManagerState state = this.state.get();
      if (state != null) {
        state.transitionService(service, NEW, STARTING);
        if (!(service instanceof NoOpService)) {
          logger.get().log(Level.FINE, "Starting {0}.", service);
        }
      }
    }

    @Override
    public void running() {
      ServiceManagerState state = this.state.get();
      if (state != null) {

      ServiceManagerState state = this.state.get();
      if (state != null) {
        state.transitionService(service, NEW, STARTING);
        if (!(service instanceof NoOpService)) {
          logger.get().log(Level.FINE, "Starting {0}.", service);
        }
      }
    }

    @Override
    public void running() {
      ServiceManagerState state = this.state.get();
      if (state != null) {

        if (StringUtil.isBlank(logFormat)) {
            useEcsFormat = "docker".equals(getEnvMap().get("FESS_APP_TYPE"));
        } else if ("ecs".equals(logFormat)) {
            useEcsFormat = true;
        }
    }

    /**
     * Get the environment map.
     * @return The environment map.
     */
    protected Map<String, String> getEnvMap() {
        if (envMap != null) {

  abstract fun clean(
    chain: List<Certificate>,
    hostname: String,
  ): List<Certificate>

  companion object {
    fun get(trustManager: X509TrustManager): CertificateChainCleaner = Platform.get().buildCertificateChainCleaner(trustManager)

    fun get(vararg caCerts: X509Certificate): CertificateChainCleaner = BasicCertificateChainCleaner(BasicTrustRootIndex(*caCerts))
  }

              .replace("$OTHER", itemReporter.reportItem(other)));
    }
  }

  private Item<T> getItem(int groupNumber, int itemNumber) {
    return new Item<>(groups.get(groupNumber).get(itemNumber), groupNumber, itemNumber);
  }

  static final class Item<T> {
    final T value;
    final int groupNumber;
    final int itemNumber;

    assertContentsAnyOrder(multimap().asMap().get(null), getValueForNullKey());
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyAbsent() {
    assertNull(multimap().asMap().get(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyUnsupported() {
    assertThrows(NullPointerException.class, () -> multimap().asMap().get(null));
  }

    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {

    public void warnAboutDeprecatedOptions(ParserRequest request, Consumer<String> printWriter) {}

    @Override
    public void displayHelp(ParserRequest request, Consumer<String> printWriter) {
        options.get(0).displayHelp(request, printWriter);
    }

    protected <T> Optional<T> returnFirstPresentOrEmpty(Function<O, Optional<T>> getter) {
        for (O option : options) {
            Optional<T> o = getter.apply(option);

                    PluginManagement pluginMgmt = (PluginManagement) context.get(PLUGIN_MANAGEMENT);
                    if (pluginMgmt != null) {
                        for (Plugin managedPlugin : pluginMgmt.getPlugins()) {
                            Object key = getPluginKey(managedPlugin);
                            Plugin addedPlugin = added.get(key);
                            if (addedPlugin != null) {

        CompletableFuture<HandleInfo> future = testReconnector.reconnectHandle("/test/file.txt", new IOException("Network error"));

        HandleInfo result = future.get();
        assertNotNull(result);
        assertEquals(testHandle, result);

        verify(mockManager).completeReconnect("/test/file.txt", true);
    }

    @Test