assertEquals((Character) 'c', table.get("foo", 3));
    assertEquals((Character) 'e', table.get("bar", 2));
    assertEquals((Character) 'f', table.get("cat", 2));
    assertSize(5);
  }

  public void testRemove() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    if (supportsRemove()) {
      assertNull(table.remove("cat", 1));
      assertNull(table.remove("bar", 3));
      assertEquals(3, table.size());

   */

  public void testSize() {
    int unused = create().size();
  }

  public void testIsEmpty() {
    boolean unused = create().isEmpty();
  }

  public void testRemove() {
    create().remove(null);
  }

  public void testClear() {
    create().clear();
  }

  public void testContainsKey() {
    boolean unused = create().containsKey(null);
  }

    assertEquals((Character) 'c', table.get("foo", 3));
    assertEquals((Character) 'e', table.get("bar", 2));
    assertEquals((Character) 'f', table.get("cat", 2));
    assertSize(5);
  }

  public void testRemove() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    if (supportsRemove()) {
      assertNull(table.remove("cat", 1));
      assertNull(table.remove("bar", 3));
      assertEquals(3, table.size());

        assertThat(list.contains("2"), is(not(true)));
        assertThat(list.contains(null), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        list.addLast(null);
        list.addLast("1");
        list.addLast("2");
        assertThat(list.remove("3"), is(not(true)));
        assertThat(list.remove("1"), is(true));

            assertTrue(EVEN.apply(toAdd));
          } catch (IllegalArgumentException e) {
            assertFalse(EVEN.apply(toAdd));
          }
        }
      }
    }

    public void testRemove() {
      for (List<Integer> contents : SAMPLE_INPUTS) {
        for (int toRemove = 0; toRemove < 10; toRemove++) {
          assertEquals(
              contents.contains(toRemove) && EVEN.apply(toRemove),

    assertEquals(0L, map.get(key));
    assertTrue(map.containsKey(key));

    assertTrue(map.replace(key, 0L, value));
    assertEquals(value, map.get(key));
  }

  public void testRemove() {
    AtomicLongMap<String> map = AtomicLongMap.create();
    String key = "key";
    assertEquals(0, map.size());
    assertTrue(map.isEmpty());
    assertEquals(0L, map.remove(key));

     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      final Map<String, Map<Integer, Character>> map;
      try {
        map = makePopulatedMap();
      } catch (UnsupportedOperationException e) {
        return;
      }

     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      final Map<String, Map<Integer, Character>> map;
      try {
        map = makePopulatedMap();
      } catch (UnsupportedOperationException e) {
        return;
      }

    assertEquals(3, (int) mmHeap.peek());
    assertEquals(3, (int) mmHeap.poll());
    assertNull(mmHeap.peekLast());
    assertNull(mmHeap.peek());
    assertNull(mmHeap.poll());
  }

  public void testRemove() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 2, 3, 4, 47, 1, 5, 3, 0));
    assertTrue("Heap is not intact initially", mmHeap.isIntact());

    } else {
      assertThrows(UnsupportedOperationException.class, () -> map.putAll(mapToPut));
    }
    assertEquals(initialSize, map.size());
    assertInvariants(map);
  }

  public void testRemove() {
    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    K keyToRemove = map.keySet().iterator().next();