*/
    public void testIsPublic() throws Exception {
        final Field f = Hoge.class.getDeclaredField("s");
        assertTrue(ModifierUtil.isPublicStaticFinalField(f));
        final Method m = Hoge.class.getDeclaredMethod("hoge", new Class[] {});
        assertTrue(ModifierUtil.isPublic(m));
    }

    /**
     * @throws Exception
     */
    public void testIsInstanceField() throws Exception {

        Method method = AdminDesignAction.class.getDeclaredMethod("isValidUploadPath", File.class, File.class);
        method.setAccessible(true);
        return (Boolean) method.invoke(action, file, baseDir);
    }

    private Boolean invokeIsValidVirtualHostPath(String path) throws Exception {
        Method method = AdminDesignAction.class.getDeclaredMethod("isValidVirtualHostPath", String.class);

        assertThat(bar, is(notNullValue()));
        assertThat(bar.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(bar.getMethod(), is(MyBean.class.getDeclaredMethod("bar", String.class)));
        assertThat(bar.getParameterTypes().length, is(1));
        assertThat(bar.getMethodName(), is("bar"));
        assertThat(bar.isPublic(), is(true));

    static WildcardType getWildcardType(String methodName) throws Exception {
      ParameterizedType parameterType =
          (ParameterizedType)
              WithWildcardType.class.getDeclaredMethod(methodName, List.class)
                  .getGenericParameterTypes()[0];
      return (WildcardType) parameterType.getActualTypeArguments()[0];
    }
  }

  public void testNewWildcardType() throws Exception {

        Method method = PrivateMethodClass.class.getDeclaredMethod("privateMethod");
        Secured secured = method.getAnnotation(Secured.class);
        assertNotNull(secured);
        assertEquals("PRIVATE_ROLE", secured.value()[0]);
    }

    @Test
    public void test_protectedMethodAnnotation() throws NoSuchMethodException {
        Method method = PrivateMethodClass.class.getDeclaredMethod("protectedMethod");

            public void hook(final FwAssistantDirector assistantDirector) {
                // Use reflection to call private method
                try {
                    Method method = FessCurtainFinallyHook.class.getDeclaredMethod("shutdownCommonsHttpClient");
                    method.setAccessible(true);
                    method.invoke(this);
                } catch (Exception e) {
                    // Expected to catch exception silently

      return invokable;
    }

    static Invokable<?, Object> method(String name, Class<?>... parameterTypes) throws Exception {
      Invokable<?, Object> invokable =
          Invokable.from(A.class.getDeclaredMethod(name, parameterTypes));
      assertThat(invokable.getName()).isEqualTo(name);
      assertEquals(A.class, invokable.getDeclaringClass());
      return invokable;
    }

    native void nativeMethod();

        }
    }

    private static Method declaredMethod(Class<?> type, String methodName, Class<?>... paramTypes) {
        try {
            return makeAccessible(type.getDeclaredMethod(methodName, paramTypes));
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    private static Method makeAccessible(Method method) {

        void testProtectedMethodAccess() throws Exception {
            // Given
            Handler testHandler = new Handler(null);

            // When
            Method method = Handler.class.getDeclaredMethod("getDefaultPort");

            // Then
            assertTrue(Modifier.isProtected(method.getModifiers()));
            method.setAccessible(true); // Required to invoke protected method

            options.propertiesPath = tempPropFile.getAbsolutePath();

            // Setup minimal mock components
            setupMockComponents();

            Method processMethod = SuggestCreator.class.getDeclaredMethod("process", SuggestCreator.Options.class);
            processMethod.setAccessible(true);

            try {
                Integer result = (Integer) processMethod.invoke(null, options);