extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testEqualsTrue() {
    new EqualsTester()
        .addEqualityGroup(multimap(), getSubjectGenerator().create(getSampleElements().toArray()))
        .testEquals();
  }

  public void testEqualsFalse() {
    List<Entry<K, V>> targetEntries = new ArrayList<>(getSampleElements());

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveAllAbsentKey() {
    assertEmpty(multimap().removeAll(k3()));
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveAllPresentKey() {
    assertContentsAnyOrder(multimap().removeAll(k0()), v0());
    expectMissing(e0());
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapToStringTester<K, V> extends AbstractMapTester<K, V> {
  public void testToString_minimal() {
    assertNotNull("toString() should not return null", getMap().toString());
  }

  @CollectionSize.Require(ZERO)
  @CollectionFeature.Require(absent = NON_STANDARD_TOSTRING)
  public void testToString_size0() {
    assertEquals("emptyMap.toString should return {}", "{}", getMap().toString());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    getMap().clear();
    assertTrue("After clear(), a map should be empty.", getMap().isEmpty());
    assertEquals(0, getMap().size());
    assertFalse(getMap().entrySet().iterator().hasNext());
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testClearConcurrentWithEntrySetIteration() {

    assertEquals("(4..8)", range.toString());
    reserializeAndAssert(range);
  }

  public void testOpen_invalid() {
    assertThrows(IllegalArgumentException.class, () -> Range.open(4, 3));
    assertThrows(IllegalArgumentException.class, () -> Range.open(3, 3));
  }

  public void testClosed() {
    Range<Integer> range = Range.closed(5, 7);
    checkContains(range);
    assertTrue(range.hasLowerBound());

    private byte[] testKey;

    @BeforeEach
    public void setUp() {
        keyManager = new SecureKeyManager();
        testKey = new byte[16];
        new SecureRandom().nextBytes(testKey);
    }

    @AfterEach
    public void tearDown() {
        if (keyManager != null) {
            keyManager.close();
        }
    }

    @Test
    public void testStoreAndRetrieveKey() {

        runner.ensureYellow();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void before() throws Exception {
        runner.admin().indices().prepareDelete("_all").execute().actionGet();
        runner.refresh();

        this.heartbeatInterval = 0;
    }

    /**
     * Sets the context handle for the heartbeat.
     *
     * @param contextHandle the context handle from registration
     */
    public void setContextHandle(byte[] contextHandle) {
        this.contextHandle = contextHandle != null ? contextHandle.clone() : null;
    }

    /**
     * Gets the context handle.
     *
     * @return the context handle

  @SuppressWarnings("IdentityHashMapBoxing")
  public void testIdentityHashMap() {
    IdentityHashMap<Integer, Integer> map = Maps.newIdentityHashMap();
    assertEquals(emptyMap(), map);
  }

  public void testConcurrentMap() {
    ConcurrentMap<Integer, Integer> map = Maps.newConcurrentMap();
    assertEquals(emptyMap(), map);
  }

  public void testTreeMap() {
    TreeMap<Integer, Integer> map = Maps.newTreeMap();

    assertFailsToDecode(base64(), "?", "Invalid input length 1");
  }

  public void testBase64CannotUpperCase() {
    assertThrows(IllegalStateException.class, () -> base64().upperCase());
  }

  public void testBase64CannotLowerCase() {
    assertThrows(IllegalStateException.class, () -> base64().lowerCase());
  }

  public void testBase64CannotIgnoreCase() {