*            {@link Object}クラスも反復する場合は {@literal true}
     */
    public ClassIterator(final Class<?> clazz, final boolean includeObject) {
        assertArgumentNotNull("clazz", clazz);
        assertArgument("clazz", !clazz.isInterface(), MessageFormatter.getSimpleMessage("ECL0103", clazz));

        this.clazz = clazz;
        this.includeObject = includeObject;
    }

    @Override
    public boolean hasNext() {

     * upcasts every method to the nearest acccessible method.
     */
    private static Method[] getAccessibleMethods(Class<?> clazz) {
        Method[] methods = clazz.getMethods();

        // Short circuit for the (hopefully) majority of cases where the
        // clazz is public
        if (Modifier.isPublic(clazz.getModifiers())) {
            return methods;
        }

    public String prompt(String message, List<String> possibleValues, String defaultReply) throws PrompterException {
        try {
            Class<?> clazz = container.getContainerRealm().loadClass(PROMPTER_CLASS);
            Object instance = container.lookup(clazz);
            Method method = clazz.getMethod("prompt", String.class, List.class, String.class);
            return (String) method.invoke(instance, message, possibleValues, defaultReply);

            }

            return convertObj(((String[]) value)[0], clazz);
        }

        return convertObj(value, clazz);
    }

    @SuppressWarnings("unchecked")
    private static <T> T convertObj(final Object value, final Class<T> clazz) {
        if (value == null) {
            return null;
        }

        if (clazz.isAssignableFrom(String.class)) {
            return (T) value.toString();
        }

     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return クラス名
     */
    public static String getSimpleClassName(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (clazz.isArray()) {
            return getSimpleClassName(clazz.getComponentType()) + "[]";
        }
        return clazz.getName();
    }

    /**

    protected <T> T convertObj(final Object value, final Class<T> clazz) {
        if (clazz.isAssignableFrom(String.class)) {
            return (T) value.toString();
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (!(value instanceof Long)) {
                return (T) Long.valueOf(value.toString());
            }
        } else if (clazz.isAssignableFrom(Integer.class)) {

        return path.replace('.', '/') + ext;
    }

    /**
     * リソースパスを返します。
     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return リソースパス
     */
    public static String getResourcePath(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return clazz.getName().replace('.', '/') + ".class";
    }

    /**
     * コンテキストクラスローダを返します。
     *

 * @author koichik
 */
public abstract class TestUtil {

    /**
     * 実際の値が期待する{@literal clazz}と等しいかを検証する{@link Matcher}を返します。
     *
     * <pre>assertThat(clazz, is(Xxx.class));</pre>
     * <p>
     * と書くと{@link CoreMatchers#is(Class)}が適用されて{@literal clazz}が {@literal Xxx}
     * のインスタンスかを検証されてしまうのでこれが必要。
     *
     * @param clazz
     *            期待するクラス
     * @return クラスをチェックする{@link Matcher}
     */

            return null;
        }
        return new DecimalFormat(pattern).format(value);
    }

    @Override
    public boolean isTarget(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);
        return Number.class.isAssignableFrom(clazz);
    }

            return null;
        }
        return StringConversionUtil.toString((Date) value, pattern);
    }

    @Override
    public boolean isTarget(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);
        return clazz == java.sql.Timestamp.class;
    }