}
        }

        MethodInstrumentationStrategy(
            @Nullable String methodName,
            @Nullable String descriptor,
            boolean generateIfNotPresent,
            BiFunction<ClassData, MethodData, MethodVisitor> methodVisitorFactory
        ) {
            this.methodName = methodName;
            this.descriptor = descriptor;
            this.generateIfNotPresent = generateIfNotPresent;

            class CustomTask extends DefaultTask {}

            class Assert {
                static def returnTypesFor(Object object, String methodName, Class... returnTypes) {
                    assert object.getClass().methods.findAll { it.name == methodName }*.returnType.name.sort() == returnTypes*.name.sort()
                }
            }

            task customTask(type: CustomTask) {

    }

    @Issue("https://github.com/gradle/gradle/issues/9487")
    def "best effort to capture multi-cause exceptions using adhoc exception type (methodName=#methodName)"() {
        given:
        buildFile << """
            apply plugin: 'java-library'

            ${mavenCentralRepository()}

            dependencies {

    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()
        val parameterTypes = readClassArray()
        return declaringClass.getDeclaredMethod(methodName, *parameterTypes)
    }

        protected void destroy() {
            final BeanDesc beanDesc = BeanDescFactory.getBeanDesc(instance.getClass());
            for (final String methodName : beanDesc.getMethodNames()) {
                final MethodDesc methodDesc = beanDesc.getMethodDescNoException(methodName);
                if (methodDesc != null) {
                    final Method method = methodDesc.getMethod();

    public static ArchCondition<JavaClass> callMethodWithName(String ownerName, String methodName) {
        return callMethodWhere(JavaCall.Predicates.target(HasOwner.Predicates.With.<JavaClass>owner(name(ownerName)))
            .and(JavaCall.Predicates.target(name(methodName))))
            .as("call method %s.%s", ensureSimpleName(ownerName), methodName);
    }

            @Nullable String instance,
            String methodName,
            Function<ExternalProcessFixture, String> groovySpecFactory,
            Function<ExternalProcessFixture, String> kotlinSpecFactory,
            Function<ExternalProcessFixture, String> javaSpecFactory
        ) {
            this.method = instance != null ? "${instance}.$methodName" : methodName
            this.groovySpecFactory = groovySpecFactory

            String methodName = methodSource.getMethodName();
            return matcher.matchesTest(methodSource.getClassName(), methodName)
                || matchesParentMethod(descriptor, methodName);
        }

        private boolean matchesParentMethod(TestDescriptor descriptor, String methodName) {
            return descriptor.getParent()

    }

    @Nullable
    private static Method findAgentMethod(String agentClassName, String methodName, Class<?>... args) {
        Class<?> agentClass = tryLoadAgentClass(agentClassName);
        if (agentClass == null) {
            return null;
        }
        try {
            Method method = agentClass.getMethod(methodName, args);
            method.setAccessible(true);
            return method;

    return Collections.singletonList(getMethod("testInverseSerialization"));
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  private static Method getMethod(String methodName) {
    return Helpers.getMethod(BiMapInverseTester.class, methodName);
  }