assertFalse(getMultiset().retainAll(singleton(e0())));
    expectContents(contents);
  }

  /**
   * Returns {@link Method} instances for the remove tests that assume multisets support duplicates
   * so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getRemoveDuplicateInitializingMethods() {

                            return 1; 
                        } else {
                            return -1;
                        }
                    });
                    // Remove duplicates (equal adjacent elements) - a new, un@Incubating type will be here twice, as 2 errors are reported; use stringified JSON to compare
                    // Filtering an array is NOT in place

     * q-quantile.
     *
     * @param indexes the quantile indexes, each of which must be in the inclusive range [0, q] for
     *     q-quantiles; the order of the indexes is unimportant, duplicates will be ignored, and the
     *     set will be snapshotted when this method is called
     * @throws IllegalArgumentException if {@code indexes} is empty
     */
    public ScaleAndIndexes indexes(int... indexes) {

    }
  }

  // TODO: test adding element of wrong type

  /**
   * Returns {@link Method} instances for the {@code setCount()} tests that assume multisets support
   * duplicates so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getSetCountDuplicateInitializingMethods() {
    return asList(

 * During this process only the most relevant version of each artifact
 * (based on group ID and artifact ID) is retained, resolving conflicts and eliminating duplicates to ensure
 * that each dependency is included only once in the final build.</p>
 *
 * <p><dfn>Dependency resolution</dfn> is the process of collecting dependencies, flattening the result graph,

        try (FileReader reader = new FileReader(file)) {
            List<UpgradedProperty> upgradedProperties = new Gson().fromJson(reader, new TypeToken<List<UpgradedProperty>>() {}.getType());
            // FIXME There should be no duplicates, yet there are some
            return upgradedProperties.stream()
                .distinct()
                .collect(ImmutableList.toImmutableList());
        } catch (IOException e) {

 * elements.
 *
 * <p>The collections created by {@link #createCollection()} may or may not allow duplicates. If the
 * collection, such as a {@link Set}, does not support duplicates, an added key-value pair will
 * replace an existing pair with the same key and value, if such a pair is present. With collections
 * like {@link List} that allow duplicates, the collection will keep the existing key-value pairs
 * while adding a new pair.
 *

    public void test_duplicateUrlsInSitemap() {
        // Test handling of duplicate URLs in sitemap
        ResponseData responseData = new ResponseData();
        byte[] content = "<sitemap></sitemap>".getBytes();
        responseData.setResponseBody(content);

        SitemapUrl sitemap1 = new SitemapUrl();
        sitemap1.setLoc("https://example.com/duplicate");

        SitemapUrl sitemap2 = new SitemapUrl();

			success: false,
		},
		// no duplicates, shall be parsed properly.
		{

   */

  /*
   * These generators also rely on consecutive integer inputs (not necessarily in order, but no
   * holes).
   */

  // SetCreationTester has some tests that pass in duplicates. Dedup them.
  private static <E extends Comparable<? super E>> SortedSet<E> nullCheckedTreeSet(E[] elements) {
    SortedSet<E> set = newTreeSet();
    for (E element : elements) {