echo "waiting until the object is tiered to run heal"
	sleep 1s
done
./mc stat sitea/bucket/README.md

success=$(./mc admin heal -r sitea/bucket/README.md --json --force | jq -r 'select((.name == "bucket/README.md") and (.after.color == "green")) | .after.color == "green"')
if [ "${success}" != "true" ]; then
	echo "Found bug expected transitioned object to report 'green'"
	exit 1
fi

            "msg": "Extra inputs are not permitted",
            "input": "plumbus",
        }
    ]
}
```

## Disable Convert Underscores { #disable-convert-underscores }

The same way as with regular header parameters, when you have underscore characters in the parameter names, they are **automatically converted to hyphens**.

	switch *flags.Spectre {
	default:
		log.Printf("unknown setting -spectre=%s", *flags.Spectre)
		os.Exit(2)
	case "":
		// nothing
	case "index":
		// known to compiler; ignore here so people can use
		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectrre=LIST
	case "all", "ret":
		ctxt.Retpoline = true
	}

	ctxt.Bso = bufio.NewWriter(os.Stdout)
	defer ctxt.Bso.Flush()

	architecture.Init(ctxt)

as if it had a "vendor/" prefix. For example, within "crypto/tls",
an import of "golang.org/x/crypto/cryptobyte" resolves to
"vendor/golang.org/x/crypto/cryptobyte". When a package with the
same path is imported from a package outside std or cmd, it will
be resolved normally. Consequently, a binary may be built with two
copies of a package at different versions if the package is

   * clazz.isAssignableFrom(x)}, but note that lambdas do not have human-readable {@link
   * #toString()} representations and are not serializable.
   *
   * @since 20.0 (since 10.0 under the incorrect name {@code assignableFrom})
   */
  @J2ktIncompatible
  @GwtIncompatible // Class.isAssignableFrom
  public static Predicate<Class<?>> subtypeOf(Class<?> clazz) {
    return new SubtypeOfPredicate(clazz);
  }

   *       CacheLoader#loadAll bulk loading implementations}
   * </ul>
   *
   * <p><b>Warning:</b> For any given key, every {@code loader} used with it should compute the same
   * value. Otherwise, a call that passes one {@code loader} may return the result of another call
   * with a differently behaving {@code loader}. For example, a call that requests a short timeout

  public static <T extends @Nullable Object> T[] newArray(Class<@NonNull T> type, int length) {
    return (T[]) Array.newInstance(type, length);
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  public static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {

        return Modifier.isFinal(method.getModifiers());
    }

    /**
     * Returns the string representation of the method signature.
     *
     * @param methodName
     *            The method name. Cannot be {@literal null} or empty
     * @param argTypes
     *            The argument types
     * @return The string representation of the method signature
     */

    public void testGetMethodNames() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(getClass());
        final String[] names = beanDesc.getMethodNames();
        for (final String name : names) {
            System.out.println(name);
        }
        assertThat(names.length > 0, is(true));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testInvalidProperty() throws Exception {

	return l.ctx
}

// Cancel function calls cancel() function
func (l LockContext) Cancel() {
	if l.cancel != nil {
		l.cancel()
	}
}

// newNSLock - return a new name space lock map.
func newNSLock(isDistErasure bool) *nsLockMap {
	nsMutex := nsLockMap{
		isDistErasure: isDistErasure,
	}
	if isDistErasure {
		return &nsMutex
	}
	nsMutex.lockMap = make(map[string]*nsLock)