}
	}
}

// Provides a fully populated http request instance, fails otherwise.
func mustNewRequest(method string, urlStr string, contentLength int64, body io.ReadSeeker, t *testing.T) *http.Request {
	req, err := newTestRequest(method, urlStr, contentLength, body)
	if err != nil {
		t.Fatalf("Unable to initialize new http request %s", err)
	}
	return req
}

				if index >= t.NumMethods() {
					return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
				}
				obj = t.Method(index) // Id-ordered

			case *types.Named:
				if index >= t.NumMethods() {
					return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
				}
				obj = t.Method(index)

			default:

    }

    def "succeeds when registering a service via #method in the correct scope in strict mode"() {
        given:
        def registry = strictScopedRegistry(Scope.BuildTree)

        when:
        registration(registry)
        registry.get(BuildTreeScopedServiceInterface) != null

        then:
        noExceptionThrown()

        where:
        method     | registration

    /**
     * Requests that a running build be canceled.  Note that this method does NOT block until the operation has been cancelled.
     */
    void requestCancel();

    /**
     * Communicates a request for build cancellation. Note that this method blocks until the operation has been cancelled.
     *

        // Bind inner providers
        for (Method method : key.getRawType().getDeclaredMethods()) {
            if (method.isAnnotationPresent(Provides.class)) {
                if (method.getTypeParameters().length != 0) {
                    throw new DIException("Parameterized method are not supported " + method);
                }
                Object qualifier = ReflectionUtils.qualifierOf(method);

	fmt.Printf("Method set of %s:\n", styp)
	fmt.Println(types.NewMethodSet(styp))

	// Output:
	// Method set of temperature.Celsius:
	// method (temperature.Celsius) String() string
	//
	// Method set of *temperature.Celsius:
	// method (*temperature.Celsius) SetF(f float64)
	// method (*temperature.Celsius) String() string
	//
	// Method set of temperature.S:
	// MethodSet {}
}

   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code
   * Optional.orElseGet}, except when {@code supplier} returns {@code null}. In this case this
   * method throws an exception, whereas the Java 8+ method returns the {@code null} to the caller.
   *
   * @throws NullPointerException if this optional's value is absent and the supplier returns {@code

//
// {
//   {matcher {function_name {regex: "composite_conv.*"}}}
//   {method {static_range_ptq
//     {input_quantized_types {
//       key: 1,
//       value {dimension_specs {dimension: 3}}}}
//   }}
// }
QuantizationSpec GetPtqSpecForConvolution(Method::MethodCase method_case) {
  QuantizationSpec spec{};
  if (method_case != Method::kStaticRangePtq) {
    return spec;
  }

    /**
     * Generates the signature for the given method
     */
    public static String signature(Method method) {
        StringBuilder builder = new StringBuilder();
        visitFormalTypeParameters(method.getTypeParameters(), builder);
        visitParameters(method.getGenericParameterTypes(), builder);
        visitType(method.getGenericReturnType(), builder);
        visitExceptions(method.getGenericExceptionTypes(), builder);

                }
            }
        """
    }

    @UnsupportedWithConfigurationCache(iterationMatchers = ".* project.javaexec")
    def "still fail when classpath doesn't shorten the command line enough with #method"() {
        def veryLongCommandLineArgs = getLongCommandLine(getMaxArgs() * 16)
        buildFile << """
            extraClasspath.from('${veryLongFileNames.join("','")}')