java.util.Set<String> methodNames =
                    java.util.Arrays.stream(methods).map(java.lang.reflect.Method::getName).collect(java.util.stream.Collectors.toSet());

            assertTrue(methodNames.contains("close"), "Should contain close method");
            assertTrue(methodNames.contains("getConfig"), "Should contain getConfig method");
            assertTrue(methodNames.contains("unwrap"), "Should contain unwrap method");

	}

	// emit methods with value receiver
	var methodNames map[string]bool
	vset := types.NewMethodSet(typ)
	for i, n := 0, vset.Len(); i < n; i++ {
		m := vset.At(i)
		if m.Obj().Exported() {
			w.emitMethod(m)
			if methodNames == nil {
				methodNames = make(map[string]bool)
			}
			methodNames[m.Obj().Name()] = true
		}
	}

    }
  }

  private static class Request {
    final String methodName;
    final Object[] arguments;

    Request(String methodName, Object[] arguments) {
      this.methodName = checkNotNull(methodName);
      this.arguments = checkNotNull(arguments);
    }
  }

  private static class Response {
    final String methodName;
    final Object result;
    final Throwable throwable;

    }
  }

  private static class Request {
    final String methodName;
    final Object[] arguments;

    Request(String methodName, Object[] arguments) {
      this.methodName = checkNotNull(methodName);
      this.arguments = checkNotNull(arguments);
    }
  }

  private static class Response {
    final String methodName;
    final Object result;
    final Throwable throwable;

    }

    @Override
    public MethodDesc[] getMethodDescs(final String methodName) {
        assertArgumentNotEmpty("methodName", methodName);

        final MethodDesc[] methodDescs = methodDescsCache.get(methodName);
        if (methodDescs == null) {
            throw new MethodNotFoundRuntimeException(beanClass, methodName, null);
        }

     *
     * @param methodName
     *            The method name. Cannot be {@literal null} or empty
     * @param argTypes
     *            The argument types
     * @return The string representation of the method signature
     */
    public static String getSignature(final String methodName, final Class<?>... argTypes) {
        assertArgumentNotEmpty("methodName", methodName);

                    "resources/upgraded-properties.json",
                    """
                        [{
                            "containingType": "com.example.Task",
                            "methodName": "getSourceCompatibility",
                            "methodDescriptor": "()Lorg/gradle/api/provider/Property;",
                            "propertyName": "sourceCompatibility",

                        <thead><tr><td>Name</td></tr></thead>
                        <tr><td>methodName</td></tr>
                    </table>
                </section>
            </chapter>
        ''')

        ClassDoc classDoc = classDoc('Class', content: content)
        MethodDoc method1 = methodDoc('methodName', id: 'method1Id', returnType: 'ReturnType1', description: 'method description', comment: 'method comment')

     *
     * @param method The method
     */
    void add(Method method) {
        String methodName = method.getName();

        List<Method> l = get(methodName);

        if (l == null) {
            l = new ArrayList<>();
            methodByNameMap.put(methodName, l);
        }

        l.add(method);
    }

    /**
     * Return a list of methods with the same name.
     *

        throws Throwable {
      String methodName = method.getName();
      Method typeVariableMethod = typeVariableMethods.get(methodName);
      if (typeVariableMethod == null) {
        if (methodName.equals("getAnnotatedBounds")
            || methodName.equals("isAnnotationPresent")
            // Each of these prefixes is shared by a family of methods:
            || methodName.startsWith("getAnnotation")