new byte[] {GREATEST, GREATEST, GREATEST});

    Comparator<byte[]> comparator = SignedBytes.lexicographicalComparator();
    Helpers.testComparator(comparator, ordered);
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testLexicographicalComparatorSerializable() {
    Comparator<byte[]> comparator = SignedBytes.lexicographicalComparator();

    this.comparator = checkNotNull(comparator);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {
    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;

    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() {

    assertEquals(
        Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator());
    assertTrue(multimap.get("x") instanceof ImmutableSortedSet);
    assertEquals(
        Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("x")).comparator());
    assertTrue(multimap.asMap().get("a") instanceof ImmutableSortedSet);
    assertEquals(

    assertThat(network.nodes()).containsExactly(4, 1, 3);
  }

  // Sorting of user-defined classes

  @Test
  public void customComparator() {
    Comparator<NonComparableSuperClass> comparator =
        new Comparator<NonComparableSuperClass>() {
          @Override
          public int compare(NonComparableSuperClass left, NonComparableSuperClass right) {
            return left.value.compareTo(right.value);

        }

        @Override
        public <T extends @Nullable Object> ComparisonChain compare(
            @ParametricNullness T left, @ParametricNullness T right, Comparator<T> comparator) {
          return classify(comparator.compare(left, right));
        }

        @Override
        public ComparisonChain compare(int left, int right) {
          return classify(Ints.compare(left, right));
        }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import java.util.Comparator;
import java.util.SortedSet;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**

    assertEquals(comparator, elementSet.comparator());
  }

  private static final Comparator<String> DEGENERATE_COMPARATOR =
      new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
          return o1.length() - o2.length();
        }
      };

  /** Test a TreeMultiset with a comparator that can return 0 when comparing unequal values. */

   * the given {@code comparator}.
   *
   * @see #testComparator(Comparator, List)
   */
  public static <T extends @Nullable Object> void testComparator(
      Comparator<? super T> comparator, T... valuesInExpectedOrder) {
    testComparator(comparator, Arrays.asList(valuesInExpectedOrder));
  }

  /**

    Ordering<@Nullable Object> comparator = Ordering.allEqual();
    assertSame(comparator, comparator.reverse());

    assertEquals(0, comparator.compare(null, null));
    assertEquals(0, comparator.compare(new Object(), new Object()));
    assertEquals(0, comparator.compare("apples", "oranges"));
    assertSame(comparator, reserialize(comparator));
    assertEquals("Ordering.allEqual()", comparator.toString());