// we know ( [
      RangeMapEntry<K, V> rangeMapEntry = mapEntryBelowToTruncate.getValue();
      if (rangeMapEntry.getUpperBound().compareTo(rangeToRemove.lowerBound) > 0) {
        // we know ( [ )
        if (rangeMapEntry.getUpperBound().compareTo(rangeToRemove.upperBound) > 0) {
          // we know ( [ ] ), so insert the range ] ) back into the map --
          // it's being split apart

          throw new ArithmeticException(x + " cannot be represented precisely as a double");
      }
    }
    X roundArbitrarilyAsX = toX(roundArbitrarily, RoundingMode.UNNECESSARY);
    int cmpXToRoundArbitrarily = x.compareTo(roundArbitrarilyAsX);
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(cmpXToRoundArbitrarily == 0);
        return roundArbitrarily;
      case FLOOR:

    assertLessThan(RUNNING, FAILED);

    assertLessThan(STOPPING, FAILED);
    assertLessThan(STOPPING, TERMINATED);
  }

  private static <T extends Comparable<? super T>> void assertLessThan(T a, T b) {
    if (a.compareTo(b) >= 0) {
      fail(String.format(Locale.ROOT, "Expected %s to be less than %s", a, b));
    }
  }

    @Override
    public String toString() {
      return rootLocaleFormat("%s%s(%s)", typeSignature, name, getTypesString(parameterTypes));
    }

    @Override
    public int compareTo(MethodSignature o) {
      return toString().compareTo(o.toString());
    }
  }

  private static final class TypeSignature {
    final List<TypeParameterSignature> parameterSignatures;

    @Override
    public String toString() {
      return rootLocaleFormat("%s%s(%s)", typeSignature, name, getTypesString(parameterTypes));
    }

    @Override
    public int compareTo(MethodSignature o) {
      return toString().compareTo(o.toString());
    }
  }

  private static final class TypeSignature {
    final List<TypeParameterSignature> parameterSignatures;

            ArtifactVersion v2 = new DefaultArtifactVersion(e2.getVersion());

            if (newerFirst) {
                return v1.compareTo(v2) > 0 ? e1 : e2;
            }

            return v1.compareTo(v2) > 0 ? e2 : e1;
        }

        if (closerFirst) {
            return depth1 < depth2 ? e1 : e2;
        }

        return depth1 < depth2 ? e2 : e1;
    }

                if (range.hasRestrictions()) {
                    return range.containsVersion(version);
                } else {
                    return range.getRecommendedVersion().compareTo(version) == 0;
                }
            } catch (InvalidVersionSpecificationException ex) {
                return false;
            }
        }

        @Override
        public String toString() {

    BigInteger min = BigInteger.ZERO;
    BigInteger max = UnsignedLong.MAX_VALUE.bigIntegerValue();
    for (BigInteger big : TEST_BIG_INTEGERS) {
      boolean expectSuccess = big.compareTo(min) >= 0 && big.compareTo(max) <= 0;
      try {
        assertThat(UnsignedLong.valueOf(big).bigIntegerValue()).isEqualTo(big);
        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {

    builder.add("baz");
    assertTrue(list.array != builder.contents);
  }

  public void testBuilderAsymptotics() {
    int[] compares = {0};
    Comparator<Integer> countingComparator =
        (i, j) -> {
          compares[0]++;
          return i.compareTo(j);
        };
    ImmutableSortedSet.Builder<Integer> builder =
        new ImmutableSortedSet.Builder<Integer>(countingComparator, 10);

  @Override
  @SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
  public int compare(Comparable<?> left, Comparable<?> right) {
    checkNotNull(left); // right null is caught later
    if (left == right) {
      return 0;
    }

    return ((Comparable<Object>) right).compareTo(left);
  }

  @Override
  public <S extends Comparable<?>> Ordering<S> reverse() {
    return Ordering.natural();