void shouldDefineGetCapacityMethod() throws NoSuchMethodException {
            // Verify method exists with correct signature
            assertNotNull(AllocInfo.class.getMethod("getCapacity"));
            assertEquals(long.class, AllocInfo.class.getMethod("getCapacity").getReturnType());
        }

        @Test
        @DisplayName("Should define getFree method")

         */

        Method currentMethod = processHandleClass.getMethod("current");
        Method infoMethod = processHandleClass.getMethod("info");
        Method userMethod = processHandleInfoClass.getMethod("user");
        Method orElseMethod = optionalClass.getMethod("orElse", Object.class);

        Object current = currentMethod.invoke(null);

    @Require(IMPLIES_BAR)
    class Tester {
      @Keep
      @Require(IMPLIES_IMPLIES_FOO)
      public void test() {}
    }

    TesterRequirements requirements = buildTesterRequirements(Tester.class.getMethod("test"));

    assertThat(requirements.getPresentFeatures())
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO, IMPLIES_BAR, BAR);
    assertThat(requirements.getAbsentFeatures()).isEmpty();
  }

     */
    @Test
    public void testMethodParameterType() throws Exception {
        final Map<TypeVariable<?>, Type> map = ParameterizedClassDescFactory.getTypeVariables(Hoge.class);
        final Method method = Hoge.class.getMethod("foo", Set.class, Map.class);
        ParameterizedClassDesc desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 0, map);
        assertThat(desc.getRawClass(), is(sameClass(Set.class)));

    sslSocketClass.getDeclaredMethod("setUseSessionTickets", Boolean::class.javaPrimitiveType)
  private val setHostname = sslSocketClass.getMethod("setHostname", String::class.java)
  private val getAlpnSelectedProtocol = sslSocketClass.getMethod("getAlpnSelectedProtocol")
  private val setAlpnProtocols =
    sslSocketClass.getMethod("setAlpnProtocols", ByteArray::class.java)

  override fun isSupported(): Boolean = AndroidPlatform.isSupported

    }

    @Test
    public void test_methodsExist() {
        // Verify required methods exist
        try {
            CustomSizeValidator.class.getMethod("initialize", CustomSize.class);
            CustomSizeValidator.class.getMethod("isValid", CharSequence.class, ConstraintValidatorContext.class);
            assertTrue("Required methods exist", true);
        } catch (final NoSuchMethodException e) {

        Method m1 = clazz.getMethod("shouldForceSigning");
        assertEquals(boolean.class, m1.getReturnType());
        assertEquals(0, m1.getParameterCount());
        assertEquals(0, m1.getExceptionTypes().length);

        // overlaps(SmbResourceLocator): boolean, declares CIFSException
        Method m2 = clazz.getMethod("overlaps", SmbResourceLocator.class);

        void shouldDefineCloseMethod() throws Exception {
            assertDoesNotThrow(() -> {
                java.lang.reflect.Method closeMethod = SmbSession.class.getMethod("close");
                assertEquals("close", closeMethod.getName());
                assertEquals(0, closeMethod.getParameterCount());
                assertEquals(void.class, closeMethod.getReturnType());

    public void test_responseData_method() {
        final ResponseData responseData = new ResponseData();

        responseData.setMethod("GET");
        assertEquals("GET", responseData.getMethod());

        responseData.setMethod("POST");
        assertEquals("POST", responseData.getMethod());
    }

    @Test
    public void test_responseData_metaDataMap() {

                logger.debug("HTTP Request: method={}", httpRequest.getMethod());
            }
            final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();
            final CorsHandler handler = factory.get(origin);
            if (handler != null) {
                handler.process(origin, request, response);

                if (OPTIONS.equals(httpRequest.getMethod())) {