}

    /**
     * @throws Exception
     */
    @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 {

public class EmptyIterator<T> implements Iterator<T> {

    /**
     * {@link EmptyIterator}を作成します。
     */
    public EmptyIterator() {
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

    @Override
    public boolean hasNext() {
        return false;
    }

    @Override
    public T next() {

        }
        final Class<?> result = clazz;
        clazz = clazz.getSuperclass();
        return result;
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

        header.next.remove();
        return first;
    }

    /**
     * 最後の要素を削除します。
     *
     * @return 最後の要素
     */
    public E removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        final E last = header.previous.element;
        header.previous.remove();
        return last;
    }

    /**

            put(convertKey(entry.getKey()), entry.getValue());
        }
    }

    @Override
    public final V remove(final Object key) {
        return super.remove(convertKey(key));
    }

    @Override
    public boolean containsKey(final Object key) {
        return super.containsKey(convertKey(key));
    }

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

    /**
     * @throws Exception
     */
    @Test
    public void testRemoveFirst() throws Exception {
        final String[] array = new String[] { "111", "222", "333" };
        final String[] newArray = ArrayUtil.remove(array, "111");
        assertThat(newArray.length, is(2));
        assertThat(newArray[0], is("222"));
        assertThat(newArray[1], is("333"));
    }

    /**
     * @throws Exception
     */

     * 破棄可能なリソースを登録解除します。
     *
     * @param disposable
     *            破棄可能なリソース。{@literal null}であってはいけません
     */
    public static synchronized void remove(final Disposable disposable) {
        assertArgumentNotNull("disposable", disposable);
        disposables.remove(disposable);
    }

    /**
     * 登録済みのリソースを全て破棄します。
     */
    public static synchronized void dispose() {
        while (!disposables.isEmpty()) {

        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return iterators[index].next();
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

            final TimeoutTask task = e.getElement();
            if (task.isCanceled()) {
                e.remove();
            } else if (!task.isStopped() && task.isExpired()) {
                expiredTask.add(task);
                if (!task.isPermanent()) {
                    e.remove();
                }
            }
        }
        return expiredTask;
    }

    /**