for (Method method : getInstanceMethodsToTest(instance.getClass(), minimalVisibility)) {
      testMethod(instance, method);
    }
  }

  ImmutableList<Method> getInstanceMethodsToTest(Class<?> c, Visibility minimalVisibility) {
    ImmutableList.Builder<Method> builder = ImmutableList.builder();
    for (Method method : minimalVisibility.getInstanceMethods(c)) {

        private final String property;
        private final Method method;
        private final Class<F> returnType;

        GetterMethodBackedPropertyAccessor(String property, Class<F> returnType, Method method) {
            this.property = property;
            this.method = method;
            this.returnType = returnType;
        }

        @Override

    checkState(method == null);
    Method[] methods = getClass().getMethods();
    Arrays.sort(
        methods,
        new Comparator<Method>() {
          @Override
          public int compare(Method a, Method b) {
            return a.getName().compareTo(b.getName());
          }
        });
    for (Method method : methods) {
      if (method.isAnnotationPresent(TestSubtype.class)) {

    subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT);

    assertTrue("Subscriber must call provided method", methodCalled);
    assertTrue(
        "Subscriber argument must be exactly the provided object.",
        methodArgument == FIXTURE_ARGUMENT);
  }

  public void testInvokeSubscriberMethod_exceptionWrapping() throws Throwable {
    Method method = getTestSubscriberMethod("exceptionThrowingMethod");

      // filter out equals/hashCode/toString
      if (method.getName().equals("equals")
          && method.getParameterTypes().length == 1
          && method.getParameterTypes()[0] == Object.class) {
        continue;
      }
      if (method.getName().equals("hashCode") && method.getParameterTypes().length == 0) {
        continue;
      }
      if (method.getName().equals("toString") && method.getParameterTypes().length == 0) {
        continue;

                            "changes": [
                                "Method has been removed"
                            ]
                        },
                        {
                            "type": "org.gradle.api.file.SourceDirectorySet",
                            "member": "Method org.gradle.api.file.SourceDirectorySet.setOutputDir(java.io.File)",

        private void addMethod(Method method) {
            if (method.getName().equals("configure")) {
                if (!method.getReturnType().equals(Void.TYPE)) {
                    throw new ServiceValidationException(String.format("Method %s.%s() must return void.", type.getName(), method.getName()));
                }
                add(configurers, method);

        String methodUnderTest = queryMethods.key
        Closure method = bind(queryMethods.value)

        when:
        container.named("a").configure(method)
        then:
        noExceptionThrown()

        when:
        container.named("a", method)
        then:
        noExceptionThrown()

        when:
        container.named("a", getType(), method)
        then:
        noExceptionThrown()

    }

    private static class MethodDetails {
        final int methodId;
        final Method method;
        final Serializer<Object[]> argsSerializer;

        MethodDetails(int methodId, Method method, Serializer<Object[]> argsSerializer) {
            this.methodId = methodId;
            this.method = method;
            this.argsSerializer = argsSerializer;
        }
    }

    public void add(WeaklyTypeReferencingMethod<?, ?> method, String problem) {
        add(method.getMethod(), problem);
    }

    @Override
    public void add(WeaklyTypeReferencingMethod<?, ?> method, String role, String problem) {
        add(method.getMethod(), role, problem);
    }

    @Override
    public void add(Method method, String role, String problem) {
        problems.add(method, role, problem);
    }

    @Override