* otherwise, the result will be equal to {@code 2^64 + bits}.
   *
   * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)}
   * instead.
   *
   * @since 14.0
   */
  public static UnsignedLong fromLongBits(long bits) {
    // TODO(lowasser): consider caching small values, like Long.valueOf
    return new UnsignedLong(bits);
  }

  /**

@GwtCompatible
final class NaturalOrdering extends Ordering<Comparable<?>> implements Serializable {
  static final NaturalOrdering INSTANCE = new NaturalOrdering();

  // TODO: b/287198172 - Consider eagerly initializing these (but think about serialization).
  @LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsFirst;
  @LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsLast;

    }

    @Override
    public Object getKey() {
        return "artifact " + artifact.getGroupId() + ":" + artifact.getArtifactId();
    }

    @Override
    public boolean isSnapshot() {
        // Don't consider the artifact's version in here, as this is stored in the directory above that
        return false;
    }

    @Override
    public int getNature() {
        if (artifact.getVersion() != null) {

 * </p>
 * <pre>
 * Map&lt;K, V&gt; syncMap = Collections.synchronizedMap(new LruHashMap&lt;&gt;(100));
 * </pre>
 * <p>
 * Alternatively, for high-concurrency scenarios, consider implementing a custom
 * LRU cache using {@link java.util.concurrent.ConcurrentHashMap} with an eviction strategy.
 * </p>
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */

  /**
   * Returns the value associated with {@code key} in this cache, or {@code null} if there is no
   * cached value for {@code key}.
   *
   * @since 11.0
   */
  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  @Nullable V getIfPresent(@CompatibleWith("K") Object key);

  /**
   * Returns the value associated with {@code key} in this cache, obtaining that value from {@code

import junit.framework.Test;

/**
 * Tests the {@link Map} implementations of {@link java.util}, suppressing tests that trip known
 * bugs in OpenJDK 6 or higher.
 *
 * @author Kevin Bourrillion
 */
// TODO(cpovirk): consider renaming this class in light of our now running it under newer JDKs.
@AndroidIncompatible // test-suite builders
public class OpenJdk6MapTests extends TestsForMapsInJavaUtil {
  public static Test suite() {

    The Apache projects are characterized by a collaborative, consensus based development process, an open and
    pragmatic software license, and a desire to create high quality software that leads the way in its field.
    We consider ourselves not simply a group of projects sharing a server, but rather a community of developers
    and users.
  </description>
  <licenses>
    <license>
      <name>The Apache Software License, Version 2.0</name>

 * such custom interfaces directly; they are implemented only in subclasses. Therefore, forwarding
 * {@code equals} would break symmetry, as the forwarding object might consider itself equal to the
 * object being tested, but the reverse could not be true. This behavior is consistent with the
 * JDK's collection wrappers, such as {@link java.util.Collections#unmodifiableCollection}. Use an

        Iterator<? extends Entry<? extends E>> iterator1 = multiset1.entrySet().iterator();
        Iterator<? extends Entry<? extends E>> iterator2 = multiset2.entrySet().iterator();
        // TODO(lowasser): consider making the entries live views
        return new AbstractIterator<Entry<E>>() {
          @Override
          protected @Nullable Entry<E> computeNext() {
            if (iterator1.hasNext()) {

        Iterator<? extends Entry<? extends E>> iterator1 = multiset1.entrySet().iterator();
        Iterator<? extends Entry<? extends E>> iterator2 = multiset2.entrySet().iterator();
        // TODO(lowasser): consider making the entries live views
        return new AbstractIterator<Entry<E>>() {
          @Override
          protected @Nullable Entry<E> computeNext() {
            if (iterator1.hasNext()) {