assertThat(hoge.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(hoge.getField(), is(MyBean.class.getDeclaredField("HOGE")));
        assertThat(hoge.getFieldName(), is("HOGE"));
        assertThat(hoge.getFieldType(), is(sameClass(String.class)));
        assertThat(hoge.isPublic(), is(true));
        assertThat(hoge.isStatic(), is(true));
        assertThat(hoge.isFinal(), is(true));

        assertThat(it.hasNext(), is(true));

        final Indexed<String> indexed1 = it.next();
        assertThat(indexed1.getIndex(), is(0));
        assertThat(indexed1.getElement(), is("aaa"));

        final Indexed<String> indexed2 = it.next();
        assertThat(indexed2.getIndex(), is(1));
        assertThat(indexed2.getElement(), is("bbb"));

        final ClUnsupportedOperationException clUnsupportedOperationException =
                new ClUnsupportedOperationException("hoge", new NullPointerException());
        assertThat(clUnsupportedOperationException.getMessage(), is("hoge"));
        assertThat(clUnsupportedOperationException.getCause(), instanceOf(NullPointerException.class));
    }

    /**
     * Test method for

        assertThat(converter.getAsString(Integer.valueOf("100")), is("100"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIsTarget() throws Exception {
        final NumberConverter converter = new NumberConverter("##0");
        assertThat(converter.isTarget(Integer.class), is(true));
        assertThat(converter.isTarget(Timestamp.class), is(not(true)));
    }

        System.out.println(result);
        assertThat(converter.getAsString(result), is("2008/01/16"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIsTarget() throws Exception {
        final SqlDateConverter converter = new SqlDateConverter("yyyy/MM/dd");
        assertThat(converter.isTarget(java.sql.Date.class), is(true));
        assertThat(converter.isTarget(java.util.Date.class), is(not(true)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Integer.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Number.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Object.class)));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**

        System.out.println(s);
        assertThat(s, is(notNullValue()));
        assertThat(s, is(equalTo("[EMsgLongSystemName0001]Hoge Hoge")));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testDispose() throws Exception {
        DisposableUtil.dispose();
        assertThat(MessageFormatter.initialized, is(not(true)));

    @Test
    public void testConcatName() {
        assertThat(ClassUtil.concatName("aaa", "bbb"), is("aaa.bbb"));
        assertThat(ClassUtil.concatName("aaa", null), is("aaa"));
        assertThat(ClassUtil.concatName("aaa", ""), is("aaa"));
        assertThat(ClassUtil.concatName(null, "bbb"), is("bbb"));
        assertThat(ClassUtil.concatName("", "bbb"), is("bbb"));
        assertThat(ClassUtil.concatName("", "bbb"), is("bbb"));

     * .
     */
    @Test
    public void testIsEmptyCollectionOfQ() {
        Collection<String> c = null;
        assertThat(CollectionsUtil.isEmpty(c), is(true));
        c = new ArrayList<String>();
        assertThat(CollectionsUtil.isEmpty(c), is(true));
    }

    /**
     * Test method for
     * {@link org.codelibs.core.collection.CollectionsUtil#isNotEmpty(java.util.Collection)}

        final String encrypted1 = cipher1.encryptText(original);
        final String encrypted2 = cipher2.encryptText(original);

        assertThat(encrypted1, is(not(encrypted2)));
        assertThat(cipher1.decryptText(encrypted1), is(original));
        assertThat(cipher2.decryptText(encrypted2), is(original));
    }

    @Test
    public void testEmptyString() {