* order described in the <a href="#iteration">class documentation</a>.
   */
  public static <K, V> ImmutableMultimap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
    return ImmutableListMultimap.of(k1, v1, k2, v2, k3, v3);
  }

  /**
   * Returns an immutable multimap containing the given entries, in the "key-grouped" insertion

      case NEXT_LOWER:
        assertEquals(nextHigherIndex - 1, answer);
        return;
      case NEXT_HIGHER:
        assertEquals(nextHigherIndex, answer);
        return;
      case INVERTED_INSERTION_INDEX:
        assertEquals(-1 - nextHigherIndex, answer);
        return;
      default:
        throw new AssertionError();
    }
  }

  public void testWithoutDups() {

      case NEXT_LOWER:
        assertEquals(nextHigherIndex - 1, answer);
        return;
      case NEXT_HIGHER:
        assertEquals(nextHigherIndex, answer);
        return;
      case INVERTED_INSERTION_INDEX:
        assertEquals(-1 - nextHigherIndex, answer);
        return;
      default:
        throw new AssertionError();
    }
  }

  public void testWithoutDups() {

    copyIntoArray(other, 0);
    return other;
  }

  /** If this collection is backed by an array of its elements in insertion order, returns it. */
  @CheckForNull
  Object[] internalArray() {
    return null;
  }

  /**
   * If this collection is backed by an array of its elements in insertion order, returns the offset
   * where this collection's elements start.
   */
  int internalArrayStart() {

   */
  RESTRICTS_ELEMENTS,

  /**
   * Indicates that a collection has a well-defined ordering of its elements. The ordering may
   * depend on the element values, such as a {@link SortedSet}, or on the insertion ordering, such
   * as a {@link LinkedHashSet}. All list tests and sorted-collection tests automatically specify
   * this feature.
   */
  KNOWN_ORDER,

  /**

    return other;
  }

  /** If this collection is backed by an array of its elements in insertion order, returns it. */
  @CheckForNull
  @Nullable
  Object[] internalArray() {
    return null;
  }

  /**
   * If this collection is backed by an array of its elements in insertion order, returns the offset
   * where this collection's elements start.
   */
  int internalArrayStart() {

        // we need ObjectCountHashMap-backed contents, with its keys and values array in direct
        // insertion order
        contents = new ObjectCountHashMap<E>(contents);
        isLinkedHash = false;
      }
      buildInvoked = true;
      // contents is now ObjectCountHashMap, but still guaranteed to be in insertion order!
      return new RegularImmutableMultiset<E>(contents);
    }
  }

   */
  RESTRICTS_ELEMENTS,

  /**
   * Indicates that a collection has a well-defined ordering of its elements. The ordering may
   * depend on the element values, such as a {@link SortedSet}, or on the insertion ordering, such
   * as a {@link LinkedHashSet}. All list tests and sorted-collection tests automatically specify
   * this feature.
   */
  KNOWN_ORDER,

  /**

    testers.add(ListToArrayTester.class);
    return testers;
  }

  /**
   * Specifies {@link CollectionFeature#KNOWN_ORDER} for all list tests, since lists have an
   * iteration ordering corresponding to the insertion order.
   */
  @Override
  public TestSuite createTestSuite() {
    withFeatures(KNOWN_ORDER);
    return super.createTestSuite();
  }

  @Override
  protected List<TestSuite> createDerivedSuites(

        CacheBuilder.newBuilder()
            .expireAfterAccess(500000, TimeUnit.MILLISECONDS)
            .maximumSize(count)
            .build();
  }

  public void testComputeIfAbsent() {
    // simultaneous insertion for same key, expect 1 winner
    doParallelCacheOp(
        count,
        n -> {
          cache.asMap().computeIfAbsent(key, k -> "value" + n);
        });
    assertEquals(1, cache.size());
  }