assertEquals("one", list.get(0));

        list.add("two");
        assertEquals(2, list.size());
        assertEquals("two", list.get(1));
    }

    @Test public void testRemove() {
        LinkedList list = new LinkedList();

        list.add("one");
        list.add("two");
        assertTrue(list.remove("one"));

        assertEquals(1, list.size());

   * of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code map.remove(x)}
   * returns the same value which {@code map.get(x)} did immediately beforehand.
   */
  @Override
  public void testRemove() {
    final Map<String, Collection<Integer>> map;
    final String keyToRemove;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }

        assertEquals(1, list.size());
        assertEquals("one", list.get(0));

        list.add("two");
        assertEquals(2, list.size());
        assertEquals("two", list.get(1));
    }

    @Test void testRemove() {
        LinkedList list = new LinkedList();

        list.add("one");
        list.add("two");
        assertTrue(list.remove("one"));

        assertEquals(1, list.size());

        assertEquals(1, list.size())
        assertEquals("one", list.get(0))

        list.add("two")
        assertEquals(2, list.size())
        assertEquals("two", list.get(1))
    }

    @Test fun testRemove() {
        val list = LinkedList()

        list.add("one")
        list.add("two")
        assertTrue(list.remove("one"))

        assertEquals(1, list.size())
        assertEquals("two", list.get(0))

        assertEquals(1, list.size())
        assertEquals('one', list.get(0))

        list.add('two')
        assertEquals(2, list.size())
        assertEquals('two', list.get(1))
    }

    @Test void testRemove() {
        def list = new LinkedList()

        list.add('one')
        list.add('two')
        assertTrue(list.remove('one'))

        assertEquals(1, list.size())
        assertEquals('two', list.get(0))

        assertEquals(1, list.size())
        assertEquals("one", list.get(0))

        list.add("two")
        assertEquals(2, list.size())
        assertEquals("two", list.get(1))
    }

    @Test def testRemove(): Unit = {
        val list = new LinkedList()

        list.add("one")
        list.add("two")
        assertTrue(list.remove("one"))

        assertEquals(1, list.size())

	checkList(l3, []interface{}{1, 2, 3, 1, 2, 3})

	l3 = a.New[int]()
	l1.PushBackList(l3)
	checkList(l1, []interface{}{1, 2, 3})
	l1.PushFrontList(l3)
	checkList(l1, []interface{}{1, 2, 3})
}

func TestRemove() {
	l := a.New[int]()
	e1 := l.PushBack(1)
	e2 := l.PushBack(2)
	a.CheckListPointers(l, []*(a.Element[int]){e1, e2})
	e := l.Front()
	l.Remove(e)
	a.CheckListPointers(l, []*(a.Element[int]){e2})

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

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