* the map. Besides being slightly shorter than code that uses {@link #getMap()}, it also ensures
   * that callers don't pass an {@link Entry} by mistake.
   */
  protected V get(K key) {
    return getMap().get(key);
  }

  protected final K k0() {
    return e0().getKey();
  }

  protected final V v0() {
    return e0().getValue();
  }

    assertThat(Comparators.max(1, 2, reverse)).isEqualTo(1);
    assertThat(Comparators.max(2, 1, reverse)).isEqualTo(1);
  }

  /**
   * Fails compilation if the signature of min and max is changed to take {@code Comparator<T>}
   * instead of {@code Comparator<? super T>}.
   */
  public void testMinMaxWithSupertypeComparator() {
    Comparator<Number> numberComparator =

    assertThat(Comparators.max(1, 2, reverse)).isEqualTo(1);
    assertThat(Comparators.max(2, 1, reverse)).isEqualTo(1);
  }

  /**
   * Fails compilation if the signature of min and max is changed to take {@code Comparator<T>}
   * instead of {@code Comparator<? super T>}.
   */
  public void testMinMaxWithSupertypeComparator() {
    Comparator<Number> numberComparator =

   *       terminate whichever thread happens to trigger the execution.
   * </ul>
   *
   * A specific warning about locking: Code that executes user-supplied tasks, such as {@code
   * ListenableFuture} listeners, should take care not to do so while holding a lock. Additionally,
   * as a further line of defense, prefer not to perform any locking inside a task that will be run

    List<?> exp = copyToList(expected);
    List<?> act = copyToList(actual);
    String actString = act.toString();

    // Of course we could take pains to give the complete description of the
    // problem on any failure.

    // Yeah it's n^2.
    for (Object object : exp) {
      if (!act.remove(object)) {
        Assert.fail(

     * look at table entries if it is 0.
     *
     * - All (synchronized) write operations should write to the "count" field after structurally
     * changing any bin. The operations must not take any action that could even momentarily
     * cause a concurrent read operation to see inconsistent data. This is made easier by the
     * nature of the read operations in Map. For example, no operation can reveal that the table

   * memory but only for as long as the user retains a reference to it. That is, the set returned by
   * {@code combinations} does not retain the individual subsets.
   *
   * @param set the set of elements to take combinations of
   * @param size the number of elements per combination
   * @return the set of all combinations of {@code size} elements from {@code set}

   * of ~1/5000, meaning that the other thread's get() call nearly always completes within 20ms if
   * it's going to complete at all).
   *
   * <p>[*] To avoid hangs, I've disabled the in-thread calls. This makes the test take (very
   * roughly) 2.5s longer. (2.5s is also the maximum length of time we will wait for a timed get
   * that is expected to succeed; the fact that the numbers match is only a coincidence.) See the

  public void testPutNullValue_supported() {
    int size = getNumElements();

    multimap().put(k3(), null);

    assertGet(k3(), Lists.newArrayList((V) null)); // ImmutableList.of can't take null.
    assertEquals(size + 1, multimap().size());
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  public void testPutNullValue_unsupported() {
    try {

 *
 * <p>If the precondition is not met, the {@code Preconditions} method throws an unchecked exception
 * of a specified type, which helps the method in which the exception was thrown communicate that
 * its caller has made a mistake. This allows constructs such as
 *
 * <pre>{@code
 * public static double sqrt(double value) {
 *   if (value < 0) {
 *     throw new IllegalArgumentException("input is negative: " + value);
 *   }