public class ConcurrentMapRemoveTester<K, V> extends AbstractMapTester<K, V> {
  @Override
  protected ConcurrentMap<K, V> getMap() {
    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_supportedPresent() {
    assertTrue(getMap().remove(k0(), v0()));
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

    Set<Entry<K, V>> entrySet = getMap().entrySet();
    Iterator<Entry<K, V>> entryItr = entrySet.iterator();
    assertEquals(e0(), entryItr.next());
    entryItr.remove();
    assertTrue(getMap().isEmpty());
    assertFalse(entrySet.contains(e0()));
  }

  public void testContainsEntryWithIncomparableKey() {
    try {

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

    expectContents(Helpers.mapEntry(k1(), (V) null));

    assertFalse(getMap().containsKey(k0()));

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

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

public class BiMapEntrySetTester<K, V> extends AbstractBiMapTester<K, V> {
  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testSetValue_valueAbsent() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

  @CollectionSize.Require(ZERO)
  public void testIsEmpty_yes() {
    assertTrue("isEmpty() should return true", getMap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testIsEmpty_no() {
    assertFalse("isEmpty() should return false", getMap().isEmpty());
  }

        final MyClass2 dest = new MyClass2();
        dest.setAaa("aaa");
        dest.setBbb("bbb");
        dest.setDdd("ddd");

        BeanUtil.copyBeanToBean(src, dest);
        assertThat(dest.getAaa(), is("111"));
        assertThat(dest.getBbb(), is(nullValue()));
        assertThat(dest.getDdd(), is("ddd"));
    }

    /**
     * @throws Exception
     */
    @Test

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

  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAll_supportedNothing() {
    getMap().putAll(emptyMap());
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPutAll_unsupportedNothing() {
    try {
      getMap().putAll(emptyMap());
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

        "getOrDefault(present, def) should return the associated value",
        v0(),
        getMap().getOrDefault(k0(), v3()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_presentNullDefault() {
    assertEquals(
        "getOrDefault(present, null) should return the associated value",
        v0(),
        getMap().getOrDefault(k0(), null));
  }

  public void testGetOrDefault_absent() {