for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {
        boolean expectRejection =
            range1.isConnected(range2) && !range1.intersection(range2).isEmpty();
        ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder();
        builder.put(range1, 1).put(range2, 2);
        try {
          ImmutableRangeMap<Integer, Integer> unused = builder.build();

        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0
        val parts = line.split(Regex(" ")).toTypedArray()

        val element = WebPlatformUrlTestData()
        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base

        List<Restriction> restrictions;

        if (r1.isEmpty() || r2.isEmpty()) {
            restrictions = Collections.emptyList();
        } else {
            restrictions = Collections.unmodifiableList(intersection(r1, r2));
        }

        ArtifactVersion version = null;
        if (!restrictions.isEmpty()) {
            for (Restriction r : restrictions) {

        boolean resolvedPluginVersions = !versions.versions.isEmpty();
        boolean searchPerformed = false;

        if (versions.releaseVersion != null && !versions.releaseVersion.isEmpty()) {
            version = versions.releaseVersion;
            repo = versions.releaseRepository;
        } else if (versions.latestVersion != null && !versions.latestVersion.isEmpty()) {
            version = versions.latestVersion;

                    + ((pathAdjustment.isEmpty()) ? 1 : 2));

            url.append(parentUrl);
            concatPath(url, pathAdjustment);
            concatPath(url, childPath);

            return url.toString();
        }

        private void concatPath(StringBuilder url, String path) {
            if (!path.isEmpty()) {

    for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {
        boolean expectRejection =
            range1.isConnected(range2) && !range1.intersection(range2).isEmpty();
        ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder();
        builder.put(range1, 1).put(range2, 2);
        try {
          ImmutableRangeMap<Integer, Integer> unused = builder.build();

    public List<CoreExtension> selectCoreExtensions(LookupInvoker<C> invoker, C context) {
        Optional<List<CoreExtensions>> coreExtensions = context.invokerRequest.coreExtensions();
        if (coreExtensions.isEmpty() || coreExtensions.get().isEmpty()) {
            return List.of();
        }

        return selectCoreExtensions(
                context, context.invokerRequest.coreExtensions().orElseThrow());
    }

    /**

                return true;
            }
            if (wildcard || testName.equals(nodeName)) {
                return (namespaceURI == null || namespaceURI.isEmpty()) || (testPrefix == null || testPrefix.isEmpty());
            }
            return false;
        }
        if (test instanceof NodeTypeTest nodeTypeTest) {
            return switch (nodeTypeTest.getNodeType()) {

    assertThat(set.tailSet(2, false)).containsExactly(3).inOrder();
    assertThat(set.tailSet(3, false)).isEmpty();
  }

  public void testTailSet_tooLarge() {
    assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).tailSet(4)).isEmpty();
  }

  public void testSubSet() {
    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());

    assertThat(notification.getKey()).isSameInstanceAs(key);
    assertThat(notification.getValue()).isSameInstanceAs(computed);
    assertThat(notification.getCause()).isEqualTo(RemovalCause.SIZE);
    assertThat(listener.isEmpty()).isTrue();
    checkEmpty(cache);
  }

  public void testGet_expireAfterWrite() {
    Object computed = new Object();
    LoadingCache<Object, Object> cache =
        CacheBuilder.newBuilder()