try {
            final DuplicateHostService duplicateHostService = ComponentUtil.getComponent(DuplicateHostService.class);
            duplicateHostList.addAll(duplicateHostService.getDuplicateHostList());
        } catch (final AutoBindingFailureException e) {
            logger.warn("DuplicateHostService is not found.", e);
        }
    }

    /**
     * Sets the list of duplicate host rules.
     *

                  actualIsOccupiedByCurrentThread.set(monitor.isOccupiedByCurrentThread());
                  actualOccupiedDepth.set(monitor.getOccupiedDepth());
                } catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertNull(thrown.get());
    assertEquals(expectedIsOccupied, actualIsOccupied.get());

          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)

                  actualIsOccupiedByCurrentThread.set(monitor.isOccupiedByCurrentThread());
                  actualOccupiedDepth.set(monitor.getOccupiedDepth());
                } catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertNull(thrown.get());
    assertEquals(expectedIsOccupied, actualIsOccupied.get());

            .collect { it.trim() }
            .grep { !it.isEmpty() }
    }

    static List<String> parentCommitsOf(String commit) {
        return getStdout("git show --format=%P --no-patch --no-show-signature $commit")
            .split(" ").collect { it.trim() }.grep { !it.isEmpty() }
    }

    @groovy.transform.ToString
    static class ExecResult {
        String stdout
        String stderr

              try {
                val callbackA = RecordingCallback()
                client.newCall(requestA).enqueue(callbackA)
                callbackA.await(requestA.url).assertBody("a")
              } catch (e: Exception) {
                throw RuntimeException(e)
              }
            }
            chain.proceed(chain.request())
          },
        ).build()
    val requestB =
      Request

   *
   * @since 11.0
   */
  @CanIgnoreReturnValue
  public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
    try {
      appendTo((Appendable) builder, parts);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
    return builder;
  }

  /**
   * Appends the string representation of each of {@code parts}, using the previously configured

    /**
     * Gets the virtual host key from the current request.
     * The key is determined by matching HTTP headers against configured virtual hosts.
     *
     * @return The virtual host key, or empty string if no match found
     */
    public String getVirtualHostKey() {
        return LaRequestUtil.getOptionalRequest().map(req -> (String) req.getAttribute(FessConfig.VIRTUAL_HOST_VALUE)).orElseGet(() -> {

      return
    }

    try {
      testHttpUrl(testData)
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Expected failure but was success: $testData")
      }
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {
        throw e
      }
    }

    // Assert that escapers throw null pointer exceptions.
    try {
      escaper.escape((String) null);
      Assert.fail("exception not thrown when escaping a null string");
    } catch (NullPointerException e) {
      // pass
    }
  }

  /**
   * Asserts that an escaper escapes the given character into the expected string.
   *
   * @param escaper the non-null escaper to test