final ExtractData result = zipExtractor.getText(in, null);

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertFalse(result.getContent().isEmpty());
    }

    /**
     * Test that ZipExtractor handles mixed valid and invalid entries gracefully.
     * Should continue processing valid entries even when some fail.
     */

 * memory cost of hashing.
 */
internal fun Array<String>.hasIntersection(
  other: Array<String>?,
  comparator: Comparator<in String>,
): Boolean {
  if (isEmpty() || other == null || other.isEmpty()) {
    return false
  }
  for (a in this) {
    for (b in other) {
      if (comparator.compare(a, b) == 0) {
        return true
      }
    }
  }
  return false
}

                if (resultsPerPage instanceof Integer) {
                    form.num = (Integer) resultsPerPage;
                }
            }
        }

        if (StringUtil.isBlank(form.q) && form.fields.isEmpty() && !form.hasConditionQuery()) {
            // redirect to index page
            form.q = null;
            return redirectToRoot();
        }

        try {
            buildFormParams(form);

	}
	nonInterIPV6s := mustGetLocalIP6().Intersection(hostIPs)

	// If intersection of two IP sets is not empty, then the host is localhost.
	isLocalv4 := !nonInterIPV4s.IsEmpty()
	isLocalv6 := !nonInterIPV6s.IsEmpty()
	if port != "" {
		return (isLocalv4 || isLocalv6) && (port == localPort), nil
	}
	return isLocalv4 || isLocalv6, nil
}

                if (sitemapUrl != null) {
                    // Only add sitemap URL if loc is not empty
                    final String loc = sitemapUrl.getLoc();
                    if (loc != null && !loc.trim().isEmpty()) {
                        sitemapSet.addSitemap(sitemapUrl);
                    } else {
                        if (logger.isDebugEnabled()) {

    return delegate.containsAll(targets);
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override
  public <T extends @Nullable Object> T[] toArray(T[] other) {

                // ignored
            }
            interpolator.addValueSource(new MapBasedValueSource(System.getProperties()));

            try {
                if (fileString != null && !fileString.isEmpty()) {
                    fileString = interpolator.interpolate(fileString, "").replace("\\", "/");
                    File file = new File(fileString);
                    return file.exists();
                }

        ExtractData data = new ExtractData();
        assertNotNull(data);
        assertNull(data.getContent());
        assertNotNull(data.getKeySet());
        assertTrue(data.getKeySet().isEmpty());
    }

    public void test_constructorWithContent() {
        // Test constructor with content
        String content = "Test content";
        ExtractData data = new ExtractData(content);

                if (plugin.isExtensions()) {
                    extensionPlugins.add(plugin);
                }
            }
        }

        if (extensionPlugins.isEmpty()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Extension realms for project " + model.getId() + ": (none)");
            }

            return new ProjectRealmCache.CacheRecord(null, null);

        case Boolean b -> b ? 1 : 0;
        default -> toInteger(o.toString());
        };
    }

    private static Integer toInteger(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Integer.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * Converts to {@literal int}.
     *
     * @param o