.toMap(linkedMapOf())
        }

    private
    fun fullyQualifiedSignatureOf(method: JavaMethod): String =
        "${method.declaringClass.binaryName}.${method.name}(${signatureOf(method)})"

    private
    fun signatureOf(method: JavaMethod): String =
        method.parameters.joinToString(separator = ",") { p ->
            if (p.isVarArgs || p.javaClass.isArray) "${p.type.binaryName}[]"

import org.gradle.internal.reflect.JavaMethod;
import org.gradle.util.internal.CollectionUtils;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

public class InstanceOptionDescriptor implements OptionDescriptor {

    private final Object object;
    private final OptionElement optionElement;
    private final JavaMethod<Object, Collection> optionValueMethod;

    private static class ReflectionPackagesFetcher implements ClassLoaderPackagesFetcher {
        private static final JavaMethod<ClassLoader, Package[]> GET_PACKAGES_METHOD = JavaMethod.of(ClassLoader.class, Package[].class, "getPackages");
        private static final JavaMethod<ClassLoader, Package> GET_PACKAGE_METHOD = JavaMethod.of(ClassLoader.class, Package.class, "getPackage", String.class);

        @Override

import org.gradle.api.provider.HasMultipleValues;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.options.Option;
import org.gradle.internal.Cast;
import org.gradle.internal.reflect.JavaMethod;
import org.gradle.model.internal.type.ModelType;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;

public class FieldOptionElement {

            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;