}
	} else {
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte(fmt.Sprintf("wanted method %q got %q", p.States[0].wantMethod, r.Method)))
	}

	p.States[0] = ptr.Empty[pilotStubState]()
	p.States = p.States[1:]
	p.Unlock()
}

func Test_command_do(t *testing.T) {
	tests := []struct {
		name              string
		method            string
		path              string
		body              string

import org.gradle.model.internal.method.WeaklyTypeReferencingMethod;

import java.lang.reflect.Method;

public interface StructBindingValidationProblemCollector extends ValidationProblemCollector {
    void add(WeaklyTypeReferencingMethod<?, ?> method, String problem);

    void add(WeaklyTypeReferencingMethod<?, ?> method, String role, String problem);

    void add(Method method, String problem);

    /**

 * limitations under the License.
 */
package org.gradle.internal.service;

import java.lang.reflect.Method;

import static org.gradle.internal.Cast.uncheckedNonnullCast;

/**
 * A service method factory that will try to use method handles if available, otherwise fallback on reflection.
 */
class DefaultServiceMethodFactory implements ServiceMethodFactory {

@Target([ElementType.METHOD, ElementType.FIELD])
@interface Tint {
    String value()
}

@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.FIELD])
@interface Ignored {
}

@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.FIELD])
@interface AlsoIgnored {
}

@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.FIELD])
@interface ItDepends {

 *
 * <h4>Subjects and inputs</h4>
 * <p>
 * Method rules declare the subject and any inputs as parameters to the method.
 * With the exception of {@link Model} methods, the subject of the rule is the, required, first parameter and all subsequent parameters are inputs.
 * For a non-void {@link Model} method, the subject (i.e. model element being created) is the return object.

  }

  private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {
    Set<Method> set = Sets.newHashSet();
    for (Method m : interfaceType.getMethods()) {
      if (declaresInterruptedEx(m)) {
        set.add(m);
      }
    }
    return set;
  }

  private static boolean declaresInterruptedEx(Method method) {
    for (Class<?> exType : method.getExceptionTypes()) {

final class MainKt$Bar$1 {
    // source: 'main.kt'
    enclosing method MainKt.Bar()V
    public final static field INSTANCE: MainKt$Bar$1
    inner (anonymous) class MainKt$Bar$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$Bar$1

        if (getGetter == null && isGetter == null) {
            return null;
        }
        Iterable<Method> getMethods = getGetter != null ? getGetter.getDeclaringMethods() : Collections.<Method>emptyList();
        Iterable<Method> isMethods = isGetter != null ? isGetter.getDeclaringMethods() : Collections.<Method>emptyList();

      /*
       * Parameter declares a method that returns AnnotatedType, which isn't available on Android.
       * This would cause NullPointerTester, which calls Class.getDeclaredMethods, to throw
       * NoClassDefFoundError.
       */
      return;
    }
    for (Method method : ParameterTest.class.getDeclaredMethods()) {
      for (Parameter param : Invokable.from(method).getParameters()) {

      /*
       * Parameter declares a method that returns AnnotatedType, which isn't available on Android.
       * This would cause NullPointerTester, which calls Class.getDeclaredMethods, to throw
       * NoClassDefFoundError.
       */
      return;
    }
    for (Method method : ParameterTest.class.getDeclaredMethods()) {
      for (Parameter param : Invokable.from(method).getParameters()) {