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)) {

    expectUnchanged();
    expectMissing(e3());
  }

  /**
   * Returns the {@link Method} instance for {@link #testAddAtIndex_nullSupported()} so that tests
   * can suppress it. See {@link CollectionAddTester#getAddNullSupportedMethod()} for details.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getAddNullSupportedMethod() {

    }

    def method(String name, ClassMetaData classMetaData) {
        return method([:], name, classMetaData)
    }

    def method(Map<String, ?> args, String name, ClassMetaData classMetaData) {
        MethodMetaData method = Mock()
        List<String> paramTypes = args.paramTypes ?: []
        _ * method.name >> name
        _ * method.overrideSignature >> "$name(${paramTypes.join(', ')})"

	testCases := []struct {
		method     string
		bucketName string
		accessKey  string
		secretKey  string
		// Sent body
		body []byte
		// Expected response
		expectedRespStatus int
		lifecycleResponse  []byte
		errorResponse      APIErrorResponse
		shouldPass         bool
	}{
		// GET empty credentials
		{
			method: http.MethodGet, bucketName: bucketName,
			accessKey:          "",

    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)) {

func guessIsRPCReq(req *http.Request) bool {
	if req == nil {
		return false
	}
	if req.Method == http.MethodGet && req.URL != nil {
		switch req.URL.Path {
		case grid.RoutePath, grid.RouteLockPath:
			return true
		}
	}

	return (req.Method == http.MethodPost || req.Method == http.MethodGet) &&
		strings.HasPrefix(req.URL.Path, minioReservedBucketPath+SlashSeparator)
}

   * ordering of the keys.
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p>This method is not type-safe, as it may be called on a map with keys that are not mutually
   * comparable.
   *

    return emptySet();
  }

  protected Collection<Method> suppressForTreeSetNatural() {
    return emptySet();
  }

  protected Collection<Method> suppressForTreeSetWithComparator() {
    return emptySet();
  }

  protected Collection<Method> suppressForCopyOnWriteArraySet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForUnmodifiableSet() {

   *
   * @param testerMethod a test method of a tester class
   * @return all the constraints implicitly or explicitly required by the method, its declaring
   *     class, or any of its superclasses.
   * @throws ConflictingRequirementsException if the requirements are mutually inconsistent.
   */
  public static TesterRequirements getTesterRequirements(Method testerMethod)
      throws ConflictingRequirementsException {

   *       </ul>
   *   <li>other method calls are dispatched to {@link #handleInvocation}.
   * </ul>
   */
  @Override
  @CheckForNull
  public final Object invoke(Object proxy, Method method, @CheckForNull @Nullable Object[] args)
      throws Throwable {
    if (args == null) {
      args = NO_ARGS;
    }
    if (args.length == 0 && method.getName().equals("hashCode")) {
      return hashCode();
    }