*/
    @Test
    public void testIsEqualsMethod() throws Exception {
        final Method equalsMethod = ClassUtil.getMethod(getClass(), "equals", Object.class);
        assertThat(MethodUtil.isEqualsMethod(equalsMethod), is(true));
        final Method hashCodeMethod = ClassUtil.getMethod(getClass(), "hashCode");
        assertThat(MethodUtil.isEqualsMethod(hashCodeMethod), is(not(true)));
    }

    /**
     *
     */

    void testNetbiosNameInterface() {
        // Verify interface methods exist
        try {
            assertNotNull(NetbiosName.class.getMethod("getName"));
            assertNotNull(NetbiosName.class.getMethod("getScope"));
            assertNotNull(NetbiosName.class.getMethod("getNameType"));
        } catch (NoSuchMethodException e) {
            fail("Method not found: " + e.getMessage());
        }
    }

    @Test

        data.setMethod(Method.HEAD);
        assertEquals(Method.HEAD, data.getMethod());
    }

    public void test_methodStringSetterGet() {
        // Test String-based method setter with GET
        RequestData data = new RequestData();
        data.setMethod(Constants.GET_METHOD);
        assertEquals(Method.GET, data.getMethod());
    }

    public void test_methodStringSetterPost() {

        final MethodDesc foo = beanDesc.getMethodDesc("foo");
        assertThat(foo, is(notNullValue()));
        assertThat(foo.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(foo.getMethod(), is(MyBean.class.getMethod("foo")));
        assertThat(foo.getMethodName(), is("foo"));
        assertThat(foo.getParameterTypes().length, is(0));
        assertThat(foo.isPublic(), is(true));

        UrlQueueImpl<Long> queue = new UrlQueueImpl<>();

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

        queue.setMethod("POST");
        assertEquals("POST", queue.getMethod());

        queue.setMethod(null);
        assertNull(queue.getMethod());
    }

    public void test_urlGetterSetter() {
        // Test URL getter/setter

     */
    @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)));

                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())) {

        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);

    @Override
    public ResponseData execute(final RequestData request) {
        return switch (request.getMethod()) {
        case GET -> doGet(request.getUrl());
        case HEAD -> doHead(request.getUrl());
        case POST -> doPost(request.getUrl());
        default -> throw new CrawlerSystemException(request.getMethod() + " method is not supported.");
        };
    }

    /**

 */
public class AnnotationUtilTest {

    /**
     * @throws Exception
     */
    @Hoge(bbb = "3")
    @Test
    public void testGetProperties() throws Exception {
        final Method m = ClassUtil.getMethod(getClass(), "testGetProperties");
        final Annotation anno = m.getAnnotation(Hoge.class);
        final Map<String, Object> props = AnnotationUtil.getProperties(anno);
        assertThat((String) props.get("aaa"), is("123"));