*/
    @Test
    public void testRemove() throws Exception {
        assertThat(map.remove("1"), is("test"));
        assertThat(map.size(), is(2));
        assertThat(map.remove("dummy"), is(nullValue()));
        assertThat(map.remove(0), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove2() throws Exception {

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class UnmodifiableListIteratorTest extends TestCase {
  @SuppressWarnings("DoNotCall")
  public void testRemove() {
    Iterator<String> iterator = create();

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
  }

      assertThrows(
          UnsupportedOperationException.class,
          () -> testInstance.putAll(ImmutableTable.of('a', 1, "blah")));
    }
  }

  public final void testRemove() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.remove('a', 1));
    }
  }

 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class UnmodifiableIteratorTest extends TestCase {

  @SuppressWarnings("DoNotCall")
  public void testRemove() {
    final String[] array = {"a", "b", "c"};

    Iterator<String> iterator =
        new UnmodifiableIterator<String>() {
          int i;

          @Override
          public boolean hasNext() {

    assertEquals(Integer.valueOf(1), map.get("foo"));
    assertNull(map.putIfAbsent("bar", 3));
    assertEquals(Integer.valueOf(3), map.get("bar"));
  }

  public void testRemove() {
    TestMap map = new TestMap();
    map.put("foo", 1);
    assertFalse(map.remove("foo", 2));
    assertFalse(map.remove("bar", 1));
    assertEquals(Integer.valueOf(1), map.get("foo"));

        assertThat(emptyIterator, is(notNullValue()));
    }

    /**
     * Test method for {@link org.codelibs.core.collection.EmptyIterator#remove()}
     * .
     */
    @Test
    public void testRemove() {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("remove"));
        final EmptyIterator<String> emptyIterator = new EmptyIterator<String>();

   */

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

        assertThat(itr.hasNext(), is(true));
        itr.next();
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("remove"));
        final ArrayIterator<String> itr = new ArrayIterator<String>("1", "2");

        assertThat(itr.next(), is("a"));
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("remove"));
        final Vector<String> vector = new Vector<String>();
        vector.add("a");

        assertThat(map.put("One", "11"), is("1"));
        assertThat(map.get("one"), is("11"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        assertThat(map.remove("ONE"), is("1"));
        assertThat(map.size(), is(1));
        assertThat(map.remove("dummy"), is(nullValue()));
    }

    /**
     * @throws Exception