T listenerCast = listenerType.cast(listener);
            JavaMethod<T, R> javaMethod = JavaMethod.of(listenerType, returnType, method.getName(), method.getParameterTypes());
            return javaMethod.invoke(listenerCast, args);
        }

        private boolean proxyEquals(Object proxy, Object other) {
            if (other == null) {

        then:
        descriptor.getAvailableValues() == [] as Set
    }

    def getAvailableValuesCallsWhenOptionValueMethodAvailable() {
        given:
        JavaMethod<Object, Collection> optionValueMethod = Mock(JavaMethod)

        when:
        InstanceOptionDescriptor descriptor = new InstanceOptionDescriptor(new SomeClass(), optionElement, optionValueMethod)
        def values = descriptor.getAvailableValues()

            jar(Stoppable)
        ]
        ClassLoader classLoader = new URLClassLoader(jars, null as ClassLoader)
        Class nativeServicesClass = classLoader.loadClass(NativeServices.getName())
        JavaMethod nativeServicesGetInstance = JavaMethod.ofStatic(nativeServicesClass, nativeServicesClass, "getInstance")

        when:
        nativeServicesGetInstance.invokeStatic()

        then:
        def e = thrown(IllegalStateException)

    }

    private ConditionEvents checkMethodCondition(ArchCondition<JavaMethod> archCondition, Class<?> clazz) {
        JavaClass javaClass = new ClassFileImporter().importClass(clazz);
        CollectingConditionEvents events = new CollectingConditionEvents();
        for (JavaMethod method : javaClass.getAllMethods()) {
            archCondition.check(method, events);
        }

 */

package org.gradle.api.internal.project.taskfactory;

import org.gradle.api.Task;
import org.gradle.internal.execution.history.changes.InputChangesInternal;
import org.gradle.internal.reflect.JavaMethod;
import org.gradle.work.InputChanges;

import java.lang.reflect.Method;

public class IncrementalTaskAction extends StandardTaskAction {
    private InputChangesInternal inputChanges;

import java.util.List;

public class RuleSourceBackedRuleAction<R, T> implements RuleAction<T> {
    private final R instance;
    private final JavaMethod<R, T> ruleMethod;
    private final List<Class<?>> inputTypes;

    private RuleSourceBackedRuleAction(R instance, JavaMethod<R, T> ruleMethod) {
        this.instance = instance;
        this.ruleMethod = ruleMethod;

        // java.lang.reflect
        val javaMethod = type.java.getDeclaredMethod(
            methodName,
            *parameterTypes.map { it.java }.toTypedArray()
        )
        assertThat(
            "java.lang.reflect parameter names match",
            javaMethod.parameters.map { it.name },
            equalTo(parameterNames)
        )

        // kotlin.reflect

import org.gradle.api.internal.tasks.InputChangesAwareTaskAction;
import org.gradle.internal.execution.history.changes.InputChangesInternal;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;
import org.gradle.internal.reflect.JavaMethod;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

import java.lang.reflect.Method;

class StandardTaskAction implements InputChangesAwareTaskAction, Describable {

        try {
            Set<URI> original = new HashSet<URI>();
            for (URL url : classLoader.getURLs()) {
                original.add(toURI(url));
            }
            JavaMethod<URLClassLoader, Object> method = JavaMethod.of(URLClassLoader.class, Object.class, "addURL", URL.class);
            for (URL classpathElement : classpathElements) {
                if (original.add(toURI(classpathElement))) {

import groovy.lang.GroovyObjectSupport;
import org.gradle.api.Action;
import org.gradle.api.file.FileCollection;
import org.gradle.api.internal.project.IsolatedAntBuilder;
import org.gradle.internal.reflect.JavaMethod;
import org.gradle.testing.jacoco.tasks.rules.JacocoLimit;
import org.gradle.testing.jacoco.tasks.rules.JacocoViolationRule;
import org.gradle.testing.jacoco.tasks.rules.JacocoViolationRulesContainer;