@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum CollectionFeature implements Feature<Collection> {
  /**
   * The collection must not throw {@code NullPointerException} on calls such as {@code
   * contains(null)} or {@code remove(null)}, but instead must return a simple {@code false}.
   */
  ALLOWS_NULL_QUERIES,
  ALLOWS_NULL_VALUES(ALLOWS_NULL_QUERIES),

  /**

        RequestParam rp = RequestParam.NO_RETRY;

        // Act: pass to the collaborator
        consumer.accept(rp);

        // Assert: interaction happened exactly once with correct argument; no other calls
        verify(consumer, times(1)).accept(RequestParam.NO_RETRY);
        verifyNoMoreInteractions(consumer);
    }

        lenient().when(servletConfig.getServletContext()).thenReturn(servletContext);

        networkExplorer = createMockedNetworkExplorer(true, "jCIFS");

        // Override init to capture parameter calls
        networkExplorer = new NetworkExplorer() {
            @Override
            public void init(ServletConfig config) throws ServletException {
                // Read the parameters to trigger verification

 | `application/x-xz`       |

All files with these extensions and mime types are excluded from compression,
even if compression is enabled for all types.

## To test the setup

To test this setup, practice put calls to the server using `mc` and use `mc ls` on
the data directory to view the size of the object.

## Explore Further

- [Use `mc` with MinIO Server](https://docs.min.io/community/minio-object-store/reference/minio-mc.html)

	String() string

	// Storage operations.

	// Returns true if disk is online and its valid i.e valid format.json.
	// This has nothing to do with if the drive is hung or not responding.
	// For that individual storage API calls will fail properly. The purpose
	// of this function is to know if the "drive" has "format.json" or not
	// if it has a "format.json" then is it correct "format.json" or not.
	IsOnline() bool

		return err
	}

	oa := Args(so)
	if oa.URL == nil || oa.URL.String() == "" {
		*a = oa
		return nil
	}

	*a = oa
	return nil
}

// AuthZPlugin - implements opa policy agent calls.
type AuthZPlugin struct {
	args   Args
	client *http.Client
}

// Enabled returns if AuthZPlugin is enabled.
func Enabled(kvs config.KVS) bool {
	return kvs.Get(URL) != ""
}

 *     return notSubtype(intList);
 *   }
 * }
 *
 * public void testMySubtypes() throws Exception {
 *   new MySubtypeTests().testAllDeclarations();
 * }
 * }
 *
 * The calls to {@link #isSubtype} and {@link #notSubtype} tells the framework what assertions need
 * to be made.
 *
 * <p>The declaration methods must be public.
 */
@AndroidIncompatible // only used by android incompatible tests.

   * process in any way, for example being sent over RPC, or saved to disk. For a general-purpose,
   * non-cryptographic hash function that will never change behavior, we suggest {@link
   * #murmur3_128}.
   *
   * <p>Repeated calls to this method on the same loaded {@code Hashing} class, using the same value
   * for {@code minimumBits}, will return identically-behaving {@link HashFunction} instances.
   *

   * listeners are added before any of the managed services are {@linkplain Service#startAsync
   * started}.
   *
   * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not
   * across calls to multiple listeners. Specifically, a given listener will have its callbacks
   * invoked in the same order as the underlying service enters those states. Additionally, at most

func (client *storageRESTClient) GetDiskID() (string, error) {
	if !client.IsOnlineWS() {
		// make sure to check if the disk is offline, since the underlying
		// value is cached we should attempt to invalidate it if such calls
		// were attempted. This can lead to false success under certain conditions
		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return "", errDiskNotFound
	}