if err != nil {
		c.Fatalf("error listing: %v", err)
	}
	v, ok := usersMap[accessKey]
	if !ok {
		c.Fatalf("user not listed: %s", accessKey)
	}
	c.Assert(v.Status, madmin.AccountEnabled)

	// 3. Associate policy and check that user can access
	_, err = s.adm.AttachPolicy(ctx, madmin.PolicyAssociationReq{
		Policies: []string{"readwrite"},
		User:     accessKey,
	})
	if err != nil {

In case of certificate-based authentication, MinIO has to map the client-provided certificate to an S3 policy. MinIO does this via the subject common name field of the X.509 certificate. So, MinIO will associate a certificate with a subject `CN = foobar` to a S3 policy named `foobar`.

    /**
     * Adds a CORS handler for the specified origin.
     *
     * @param origin the origin pattern (can be "*" for wildcard)
     * @param handler the CORS handler to associate with the origin
     */
    public void add(final String origin, final CorsHandler handler) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", origin);
        }

     * For other types of values, they are registered directly.
     *
     * @param data the RenderData object to register the value in
     * @param key the key to associate with the value
     * @param value the value to register; can be null, Entity, Collection, or any other object
     */
    public static void register(final RenderData data, final String key, final Object value) {

- The user can now use these credentials to make requests to the MinIO server.

The administrator will associate IAM access policies with each group and if required with the user too. The MinIO server then evaluates applicable policies on a user (these are the policies associated with the groups along with the policy on the user if any) to check if the request should be allowed or denied.

Transition tiers can be added to MinIO using `mc admin tier add` command to associate a `gcs`, `s3` or `azure` bucket or prefix path on a bucket to the tier name.

     *
     * @param key
     *            cache key
     */
    void setKey(String key);

    /**
     * Set the cache map for this referral
     *
     * @param map the cache map to associate with this referral
     */
    void setCacheMap(Map<String, DfsReferralDataInternal> map);

    /**
     * Replaces the entry with key in the cache map with this referral
     */
    void replaceCache();

    private static final long serialVersionUID = 1L;

    /**
     * The internal LRU hash map used to store elements.
     */
    private final LruHashMap<E, Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Creates a new {@link LruHashSet} with the specified limit size.
     *
     * @param limitSize

  }

  @Override
  public String toString() {
    return map.toString();
  }

  /**
   * If {@code key} is not already associated with a value or if {@code key} is associated with
   * zero, associate it with {@code newValue}. Returns the previous value associated with {@code
   * key}, or zero if there was no mapping for {@code key}.
   */
  long putIfAbsent(K key, long newValue) {

        return filterChain.execute(context, query, boost);
    }

    /**
     * Adds a query command to the processor.
     *
     * @param name the name to associate with the command (typically the query class simple name)
     * @param queryCommand the query command implementation to add
     * @throws IllegalArgumentException if name or queryCommand is null
     */