assertEquivalent(stats.mean(), streamStats.getAverage());
      assertEquivalent(stats.sum(), streamStats.getSum());
      assertEquivalent(stats.max(), streamStats.getMax());
      assertEquivalent(stats.min(), streamStats.getMin());
    }
  }

  private static void assertEquivalent(double actual, double expected) {
    if (expected == POSITIVE_INFINITY) {

        if (violation.getHumanExplanation().startsWith(SINCE_ERROR_MESSAGE)) {
            // We want to keep @since nagging for new methods, unless it's `getX` or `getIsX` method that replaces `isX` boolean method.
            return isCurrentGetterThatReplacesBooleanIsGetter(jApiMethod, currentAccessors) || isKotlinBooleanSourceCompatibilityMethod(jApiMethod, currentAccessors);
        }

    assertTrue(getMap().remove(k0(), v0()));
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedPresentKeyWrongValue() {
    assertFalse(getMap().remove(k0(), v3()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedWrongKeyPresentValue() {
    assertFalse(getMap().remove(k3(), v0()));

    extends AbstractContainerTester<Map<K, V>, Entry<K, V>> {
  protected Map<K, V> getMap() {
    return container;
  }

  @Override
  protected Collection<Entry<K, V>> actualContents() {
    return getMap().entrySet();
  }

  /** @see AbstractContainerTester#resetContainer() */
  protected final void resetMap() {
    resetContainer();
  }

@ElementTypesAreNonnullByDefault
public abstract class AbstractBiMapTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMapTester<K, V> {

  @Override
  protected BiMap<K, V> getMap() {
    return (BiMap<K, V>) super.getMap();
  }

  static <K extends @Nullable Object, V extends @Nullable Object> Entry<V, K> reverseEntry(
      Entry<K, V> entry) {
    return mapEntry(entry.getValue(), entry.getKey());
  }

  @Override
  protected ConcurrentMap<K, V> getMap() {
    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_supportedPresent() {
    assertTrue(getMap().replace(k0(), v0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

    getMap().forcePut(null, v1());

    expectContents(mapEntry((K) null, v1()));

    assertFalse(getMap().containsValue(v0()));

    assertTrue(getMap().containsValue(v1()));
    assertTrue(getMap().inverse().containsKey(v1()));
    assertNull(getMap().inverse().get(v1()));
    assertEquals(v1(), getMap().get(null));
    assertEquals(1, getMap().size());
  }

    assertFalse(
        "Maps of different sizes should not be equal.", getMap().equals(newHashMap(moreEntries)));
  }

  public void testEquals_list() {
    assertFalse(
        "A List should never equal a Map.", getMap().equals(copyToList(getMap().entrySet())));
  }

  private static <K, V> Map<K, V> newHashMap(

  @MapFeature.Require(SUPPORTS_PUT)
  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@ElementTypesAreNonnullByDefault
public class ConcurrentMapPutIfAbsentTester<K, V> extends AbstractMapTester<K, V> {
  @Override
  protected ConcurrentMap<K, V> getMap() {
    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3()));