* @param clazz
     *            the class to check. Must not be null.
     * @return true if abstract, false otherwise
     */
    public static boolean isAbstract(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return isAbstract(clazz.getModifiers());
    }

    /**
     * Checks if the specified modifier is abstract.
     *
     * @param modifier

    }

    @Override
    public boolean isFinal() {
        return MethodUtil.isFinal(method);
    }

    @Override
    public boolean isAbstract() {
        return MethodUtil.isAbstract(method);
    }

    @Override
    public boolean isParameterized(final int index) {
        assertArgumentArrayIndex("index", index, parameterTypes.length);

     */
    boolean isFinal();

    /**
     * Returns {@literal true} if the method is {@literal abstract}.
     *
     * @return {@literal true} if the method is {@literal abstract}
     */
    boolean isAbstract();

    /**
     * Returns {@literal true} if the method's parameter type at the specified index is parameterized.
     *
     * @param index
     *            the index of the parameter

        assertFalse(ModifierUtil.isTransient(f));
    }

    /**
     * @throws Exception
     */
    public void testIsAbstract() throws Exception {
        assertTrue(ModifierUtil.isAbstract(Map.class));
        assertFalse(ModifierUtil.isAbstract(HashMap.class));
    }

    /**
     *
     */
    public static class Hoge {

        /**
         *
         */
        public static final String s = null;

        assertThat(foo.getParameterTypes().length, is(0));
        assertThat(foo.isPublic(), is(true));
        assertThat(foo.isStatic(), is(not(true)));
        assertThat(foo.isFinal(), is(not(true)));
        assertThat(foo.isAbstract(), is(not(true)));
        assertThat(foo.invoke(new MyBean()), is((Object) "hoge"));
    }

    /**
     * @throws Exception
     */
    @Test(expected = MethodNotStaticRuntimeException.class)

        String appWebPkg = ".app.web.";
        String actionSuffix = "Action";

        // ## Act ##
        policeStoryOfJavaClassChase((srcFile, clazz) -> {
            if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) { // e.g. BaseAction
                return;
            }
            final String className = clazz.getName();
            if (className.contains(appWebPkg) && className.endsWith(actionSuffix)) {

        assertTrue("Class should be public", java.lang.reflect.Modifier.isPublic(HotThreadMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be abstract", java.lang.reflect.Modifier.isAbstract(HotThreadMonitorTarget.class.getModifiers()));
        assertFalse("Class should not be final", java.lang.reflect.Modifier.isFinal(HotThreadMonitorTarget.class.getModifiers()));
    }

    @Test

            // When
            int modifiers = Handler.class.getModifiers();

            // Then
            assertTrue(Modifier.isPublic(modifiers));
            assertFalse(Modifier.isAbstract(modifiers));
            assertFalse(Modifier.isInterface(modifiers));
        }
    }

            // When
            int modifiers = Handler.class.getModifiers();

            // Then
            assertTrue(Modifier.isPublic(modifiers));
            assertFalse(Modifier.isAbstract(modifiers));
            assertFalse(Modifier.isInterface(modifiers));
        }
    }

        assertFalse("FessWebResourceRoot should not be abstract",
                java.lang.reflect.Modifier.isAbstract(FessWebResourceRoot.class.getModifiers()));
    }

    @Test
    public void test_constructorSignature() {
        // Verify constructor parameter types
        try {