private static final Comparator<@Nullable Integer> DECREASING_INT_COMPARATOR =
      Ordering.<Integer>natural().reverse().<Integer>nullsFirst();

  private SetMultimap<String, Integer> create() {
    return TreeMultimap.create(StringLength.COMPARATOR, DECREASING_INT_COMPARATOR);
  }

  /** Create and populate a {@code TreeMultimap} with explicit comparators. */

    assertEquals(multimap, copy);
  }

  private static final Comparator<Double> KEY_COMPARATOR = Ordering.natural();

  private static final Comparator<Double> VALUE_COMPARATOR =
      Ordering.<Double>natural().reverse().nullsFirst();

  /**
   * Test that creating one TreeMultimap from another does not copy the comparators from the source
   * TreeMultimap.
   */
  public void testCreateFromTreeMultimap() {

  /**
   * Creates a {@code MonitorBasedPriorityBlockingQueue} with the specified initial capacity that
   * orders its elements according to the specified comparator.
   *
   * @param initialCapacity the initial capacity for this priority queue
   * @param comparator the comparator that will be used to order this priority queue. If {@code
   *     null}, the {@linkplain Comparable natural ordering} of the elements will be used.

  Iterator<C> createColumnKeyIterator() {
    return new ColumnKeyIterator();
  }

  private final class ColumnKeyIterator extends AbstractIterator<C> {
    // Use the same map type to support TreeMaps with comparators that aren't
    // consistent with equals().
    final Map<C, V> seen = factory.get();
    final Iterator<Map<C, V>> mapIterator = backingMap.values().iterator();
    Iterator<Entry<C, V>> entryIterator = emptyIterator();

    Comparator<Comparable<?>> comparator = Ordering.natural().reverse();
    SortedSet<String> set =
        new ImmutableSortedSet.Builder<String>(comparator).add("a", "b", "c").build();
    SortedSet<String> copy = SerializableTester.reserializeAndAssert(set);
    assertTrue(elementsEqual(set, copy));
    assertEquals(set.comparator(), copy.comparator());
  }

  public void testReverseOrder() {

    // The VarHandle, Unsafe, or Java implementation.
    Comparator<byte[]> comparator = UnsignedBytes.lexicographicalComparator();
    Helpers.testComparator(comparator, ordered);
    assertThat(SerializableTester.reserialize(comparator)).isSameInstanceAs(comparator);

    // The Java implementation.
    Comparator<byte[]> javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();

   * ClassCastException}.
   *
   * @param comparator the comparator that will be used to sort this multiset. A null value
   *     indicates that the elements' <i>natural ordering</i> should be used.
   */
  @SuppressWarnings("unchecked")
  public static <E extends @Nullable Object> TreeMultiset<E> create(
      @Nullable Comparator<? super E> comparator) {
    return (comparator == null)

  public void testOrderedByComparator() {
    Comparator<? super K> comparator = navigableMap.comparator();
    if (comparator == null) {
      comparator = NATURAL_ORDER;
    }
    Iterator<Entry<K, V>> entryItr = navigableMap.entrySet().iterator();
    Entry<K, V> prevEntry = entryItr.next();
    while (entryItr.hasNext()) {
      Entry<K, V> nextEntry = entryItr.next();

    assertMapEquals(copy, "two", 2, "three", 3, "one", 1);
    assertThat(ImmutableSortedMap.copyOf(copy, comparator)).isSameInstanceAs(copy);
    assertThat(copy.comparator()).isEqualTo(comparator);
  }

  public void testCopyOfImmutableSortedSetDifferentComparator() {
    Comparator<String> comparator = Ordering.<String>natural().reverse();

  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public Comparator<? super E> comparator() {
    Comparator<? super E> comparator = delegate.comparator();
    if (comparator != null) {
      return comparator;
    }
    return NATURAL_ORDER;
  }

  @Override
  public boolean contains(Object object) {