return false;
        }
        prev = next;
      }
    }
    return true;
  }

  /**
   * Returns a {@code Collector} that returns the {@code k} smallest (relative to the specified
   * {@code Comparator}) input elements, in ascending order, as an unmodifiable {@code List}. Ties
   * are broken arbitrarily.
   *
   * <p>For example:
   *
   * {@snippet :

            return modelSource.getLocation();
        }

        @Override
        @Nullable
        public Source resolve(@Nonnull String relative) {
            if (modelSource instanceof ModelSource2 ms) {
                return toSource(ms.getRelatedSource(relative));
            } else {
                return null;
            }
        }

        @Override
        public boolean equals(Object o) {

      return emptySet();
    }
  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<

            } else if (file.getPath().startsWith(File.separator)) {
                // drive-relative Windows path, don't align with project directory but with drive root
                file = file.getAbsoluteFile();
            } else {
                // an ordinary relative path, align with project directory
                file = new File(new File(basedir, file.getPath()).toURI().normalize()).getAbsoluteFile();

    assertEquals("/a/b/c/g;x=1/y", simplifyPath("/a/b/c/g;x=1/./y"));
    assertEquals("/a/b/c/y", simplifyPath("/a/b/c/g;x=1/../y"));
  }

  /** http://gbiv.com/protocols/uri/rfc/rfc3986.html#relative-normal */
  public void testRfc3986Normal() {
    assertEquals("/a/b/c/g", simplifyPath("/a/b/c/g"));
    assertEquals("/a/b/c/g", simplifyPath("/a/b/c/./g"));
    assertEquals("/a/b/c/g", simplifyPath("/a/b/c/g/"));

        // Find the common root of all POM paths to preserve relative structure
        Path commonRoot = findCommonRoot(pomMap.keySet());
        context.debug("Common root: " + commonRoot);

        // Write each POM to the temp directory, preserving relative structure
        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
            Path originalPath = entry.getKey();

      this.className = checkNotNull(className);
    }

    /**
     * Configures the {@link ToStringHelper} so {@link #toString()} will ignore properties with null
     * value. The order of calling this method, relative to the {@code add()}/{@code addValue()}
     * methods, is not significant.
     *
     * @since 18.0 (since 12.0 as {@code Objects.ToStringHelper.omitNullValues()}).
     */
    @CanIgnoreReturnValue

      return emptySet();
    }
  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<

    }

    return derivedSuites;
  }

  /**
   * Creates a suite whose set has some elements filtered out of view.
   *
   * <p>Because the set may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubsetSuite(

          <name>subprojects</name>
          <version>4.1.0+</version>
          <description>The subprojects (formerly called modules) to build as a part of this
            project. Each subproject listed is a relative path to the directory containing the subproject.
            To be consistent with the way default URLs are calculated from parent, it is recommended
            to have subproject names match artifact ids.</description>