@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;

       */
      do {
        approxLog10--;
        approxPow = approxPow.divide(BigInteger.TEN);
        approxCmp = approxPow.compareTo(x);
      } while (approxCmp > 0);
    } else {
      BigInteger nextPow = BigInteger.TEN.multiply(approxPow);
      int nextCmp = nextPow.compareTo(x);
      while (nextCmp <= 0) {
        approxLog10++;
        approxPow = nextPow;
        approxCmp = nextCmp;

      // 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

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

        @Override
        public String toString() {

  @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();

          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:

            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;
    }

    @SuppressWarnings("unchecked") // The null value can compare with any Object
    Comparable<Object> comparable = ArbitraryInstances.get(Comparable.class);
    assertEquals(0, comparable.compareTo(comparable));
    assertThat(comparable.compareTo("")).isGreaterThan(0);
    assertThrows(NullPointerException.class, () -> comparable.compareTo(null));
  }

  public void testGet_array() {

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