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

## Set bucket quota configuration

### Set a hard quota of 1GB for a bucket `mybucket` on MinIO object storage

```sh
mc admin bucket quota myminio/mybucket --hard 1gb
```

### Verify the quota configured on `mybucket` on MinIO

```sh

        assertEquals(mockCredentials, wrapper.getCredentials(), "Initial credentials should be set by constructor");
    }

    @Test
    @DisplayName("Should return the credentials provided in the constructor")
    void testGetCredentials() {
        assertEquals(mockCredentials, wrapper.getCredentials(), "getCredentials should return the initially set credentials");
    }

    @Test

var ErrInvalidChecksum = errors.New("invalid checksum")

// SetExpectedMin set expected minimum data expected from reader
func (r *Reader) SetExpectedMin(expectedMin int64) {
	r.expectedMin = expectedMin
}

// SetExpectedMax set expected max data expected from reader
func (r *Reader) SetExpectedMax(expectedMax int64) {
	r.expectedMax = expectedMax
}

            infoLevel.setAccessible(true);
            assertEquals(Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO, infoLevel.getInt(resp));

            // Verify subCommand is set correctly
            Field subCmd = SmbComTransactionResponse.class.getDeclaredField("subCommand");
            subCmd.setAccessible(true);

        // Test multiple calls to readDataWireFormat to ensure buffer is overwritten
        byte[] firstData = "First data set".getBytes();
        byte[] secondData = "Second data set".getBytes();
        byte[] buffer1 = new byte[100];
        byte[] buffer2 = new byte[100];

        System.arraycopy(firstData, 0, buffer1, 0, firstData.length);

        (Class<TestEnum>) Class.forName(TestEnum.class.getName(), false, shadowLoader);
    assertThat(shadowTestEnum).isNotEqualTo(TestEnum.class);
    // We can't write Set<TestEnum> because that is a Set of the TestEnum from the original
    // ClassLoader.
    Set<Object> shadowConstants = new HashSet<>();
    for (TestEnum constant : TestEnum.values()) {
      Optional<TestEnum> result = Enums.getIfPresent(shadowTestEnum, constant.name());

        // Inject the ShareInfoCtr1 using reflection
        Field infoField = srvsvc.ShareEnumAll.class.getDeclaredField("info");
        infoField.setAccessible(true);
        infoField.set(msrpcShareEnum, shareInfoCtr1);

        // Test getEntries method
        FileEntry[] entries = msrpcShareEnum.getEntries();

        assertNotNull(entries);
        assertEquals(2, entries.length);

  // This is needed when resolving types against a context with wildcards
  // For example:
  // class Holder<T> {
  //   void set(T data) {...}
  // }
  // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
  // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.
  private static class WildcardCapturer {

    static final WildcardCapturer INSTANCE = new WildcardCapturer();

    private static final Logger logger = LogManager.getLogger(AbstractIntervalController.class);

    /**
     * Indicates whether exceptions during the delay process should be ignored.
     * If set to true, exceptions will be caught and ignored. If set to false,
     * exceptions will be re-thrown as {@link CrawlerSystemException}.
     * Default value is true.
     */
    protected boolean ignoreException = true;

    /**

    List<Entry<K, V>> entries = copyToList(multimap().entries());

    for (Entry<K, V> entry : entries) {
      resetContainer();
      K k = entry.getKey();
      V v = entry.getValue();

      Set<V> values = multimap().get(k);
      Set<V> expectedValues = copyToSet(values);

      assertFalse(multimap().put(k, v));
      assertEquals(expectedValues, values);
      assertGet(k, expectedValues);
    }
  }