assertEquals(0, sb2.length());

    try {
      joiner.appendTo(NASTY_APPENDABLE, set);
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, set.iterator());
    } catch (IOException e) {
      throw new AssertionError(e);
    }

    try {
      joiner.appendTo(NASTY_APPENDABLE, array);

     */
    @JvmField
    val SYSTEM: Dns = DnsSystem()

    private class DnsSystem : Dns {
      override fun lookup(hostname: String): List<InetAddress> {
        try {
          return InetAddress.getAllByName(hostname).toList()
        } catch (e: NullPointerException) {
          throw UnknownHostException("Broken system behaviour for dns lookup of $hostname").apply {
            initCause(e)

    Range<C> expectedSpan = null;
    if (itr.hasNext()) {
      expectedSpan = itr.next();
      while (itr.hasNext()) {
        expectedSpan = expectedSpan.span(itr.next());
      }
    }

    try {
      Range<C> span = rangeSet.span();
      assertEquals(expectedSpan, span);
    } catch (NoSuchElementException e) {
      assertNull(expectedSpan);
    }

        String jdk = activation.getJdk();

        // null case is covered by canDetermineActivation(), so we can do a straight startsWith() here.
        if (jdk.startsWith("[") || jdk.startsWith("(")) {
            try {
                return matchJdkVersionRange(jdk);
            } catch (InvalidVersionSpecificationException e) {
                throw new ProfileActivationException(

        throw new IllegalArgumentException(
            "missing event subscriber for an annotated method. Is " + listener + " registered?");
      }

      // don't try to remove the set if it's empty; that can't be done safely without a lock
      // anyway, if the set is empty it'll just be wrapping an array of length 0
    }
  }

  @VisibleForTesting

    public static final String CHILDREN_COMBINATION_APPEND = "append";
    /**
     * Default mode for combining children DOMs during merge.
     * When element names match, the process will try to merge the element data,
     * rather than putting the dominant and recessive elements as siblings.
     */
    public static final String DEFAULT_CHILDREN_COMBINATION_MODE = CHILDREN_COMBINATION_MERGE;

                enc = getFessConfig().getCrawlerDocumentSiteEncoding();
            } else {
                enc = encoding;
            }

            try {
                url = URLDecoder.decode(url, enc);
            } catch (final Exception e) {}
        }

        return abbreviateSite(url);
    }

    /**

        // Set info to SmbInfoAllocation
        SmbInfoAllocation allocation = new SmbInfoAllocation();
        setInfoField(response, allocation);

        // Try to get as FileFsSizeInformation (incompatible)
        assertThrows(CIFSException.class, () -> {
            response.getInfo(FileFsSizeInformation.class);
        });
    }

    @Test

        validate(form, messages -> {}, () -> asHtml(virtualHost(path_Error_ErrorJsp)));
        if (isLoginRequired()) {
            return redirectToLogin();
        }

        Map<String, Object> doc = null;
        try {
            doc = searchHelper.getDocumentByDocId(form.docId, queryFieldConfig.getCacheResponseFields(), getUserBean()).orElse(null);
        } catch (final Exception e) {

        for (final WebResource possibleJar : possibleJars) {
            if (possibleJar.isFile() && possibleJar.getName().endsWith(".jar")) {
                try (final JarFile jarFile = new JarFile(possibleJar.getCanonicalPath())) {
                    final Manifest manifest = jarFile.getManifest();
                    if (manifest != null && manifest.getEntries() != null) {