ClassDoc classDoc = classDoc('Class', content: content)
        MethodDoc method1 = methodDoc('methodName', id: 'method1Id', returnType: 'ReturnType1', description: 'method description', comment: 'method comment')
        MethodDoc method2 = methodDoc('methodName', id: 'method2Id', returnType: 'ReturnType2', description: 'overloaded description', comment: 'overloaded comment', paramTypes: ['ParamType'])
        _ * classDoc.classProperties >> []

  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();
    TestSubtype spec = method.getAnnotation(TestSubtype.class);
    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))
        .isTrue();
    assertWithMessage("%s is supertype of %s", returnType, paramType)

            Objects.equals(returnType, that.returnType);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), name, ownerClass, parameters, returnType);
    }

    public ClassMetaData getOwnerClass() {
        return ownerClass;
    }

    public TypeMetaData getReturnType() {
        return returnType;
    }

  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();
    TestSubtype spec = method.getAnnotation(TestSubtype.class);
    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))
        .isTrue();
    assertWithMessage("%s is supertype of %s", returnType, paramType)

private
fun ApiTypeProvider.Context.apiTypeUsageForReturnType(delegate: MethodNode, returnType: TypeSignatureVisitor?) =
    apiTypeUsageFor(
        binaryName = returnType?.binaryName ?: Type.getReturnType(delegate.desc).className,
        isNullable = delegate.isReturnTypeNullable,
        variance = returnType?.variance ?: Variance.INVARIANT,
        typeArguments = returnType?.typeArguments ?: emptyList()
    )


private

    def formatsSignature() {
        method.returnType = new TypeMetaData('ReturnType')
        method.addParameter('param1', new TypeMetaData('ParamType'))
        method.addParameter('param2', new TypeMetaData('ParamType2'))

        expect:
        method.signature == 'ReturnType method(ParamType param1, ParamType2 param2)'
        method.overrideSignature == 'method(ParamType, ParamType2)'

        String name = methodDeclaration.getNameAsString();

        String rawCommentText = getJavadocComment(methodDeclaration);
        TypeMetaData returnType = extractTypeName(methodDeclaration.getType());
        MethodMetaData methodMetaData = getCurrentClass().addMethod(name, returnType, rawCommentText);

        findAnnotations(methodDeclaration, methodMetaData);
        extractParameters(methodDeclaration, methodMetaData);

    ): Any? {
      val callArgs = args ?: arrayOf<Any?>()
      val methodName = method.name
      val returnType = method.returnType
      if (methodName == "supports" && Boolean::class.javaPrimitiveType == returnType) {
        return true // ALPN is supported.
      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null

            param.type = new TypeMetaData(it)
            return param
        }
        _ * method.ownerClass >> classMetaData
        _ * method.returnType >> new TypeMetaData(args.returnType ?: 'ReturnType')
        _ * javadocConverter.parse(method, !null) >> ({[parse("<para>${args.comment ?: 'comment'}</para>")]} as DocComment)
        return method
    }

    def methodDoc(String name) {

    protected final String methodName;

    /** Array of method parameter types */
    protected final Class<?>[] parameterTypes;

    /** The return type of the method */
    protected final Class<?> returnType;

    /** Information about parameterized argument types */
    protected final ParameterizedClassDesc[] parameterizedClassDescs;

    /** Information about the parameterized return type */