Thread.interrupted();
    }
  }

  /**
   * awaitFullGc() is not quite as reliable a way to ensure calling of a specific finalize method as
   * the more direct await* methods, but should be reliable enough in practice to avoid flakiness of
   * this test. (And if it isn't, we'd like to know about it first!)
   */
  public void testAwaitFullGc() {
    final CountDownLatch finalizerRan = new CountDownLatch(1);

      Thread.interrupted();
    }
  }

  /**
   * awaitFullGc() is not quite as reliable a way to ensure calling of a specific finalize method as
   * the more direct await* methods, but should be reliable enough in practice to avoid flakiness of
   * this test. (And if it isn't, we'd like to know about it first!)
   */
  public void testAwaitFullGc() {
    final CountDownLatch finalizerRan = new CountDownLatch(1);

- Erasure coding used by MinIO is [Reed-Solomon](https://github.com/klauspost/reedsolomon) erasure coding scheme, which has a total shard maximum of 256 i.e 128 data and 128 parity. MinIO design goes beyond this limitation by doing some practical architecture choices.

        }
        return new String( c );
    }

/** 
 * This is the same as {@link jcifs.smb1.util.Hexdump#toHexString(int val, int
 * size)} but provides a more practical form when trying to avoid {@link
 * java.lang.String} concatenation and {@link java.lang.StringBuffer}.
 */ 
    public static void toHexChars( int val, char dst[], int dstIndex, int size ) {
        while( size > 0 ) {

    // This approach does mean that we break out of the fast path code in cases
    // where we don't strictly need to, but this situation will almost never
    // occur in practice.
    if (safeMin >= Character.MIN_HIGH_SURROGATE) {
      // The safe range is empty or the all safe code points lie in or above the
      // surrogate range. Either way the character range is empty.

    if (escaper instanceof UnicodeEscaper) {
      return (UnicodeEscaper) escaper;
    } else if (escaper instanceof CharEscaper) {
      return wrap((CharEscaper) escaper);
    }
    // In practice this shouldn't happen because it would be very odd not to
    // extend either CharEscaper or UnicodeEscaper for non-trivial cases.
    throw new IllegalArgumentException(

Once the **patch** is successfully applied, developer must run tests to validate the fix that was backported by running following tests, locally.

Unit tests

```
λ make test
```

        return toHexString(data, 0, data.length);
    }


    /**
     * This is the same as {@link jcifs.util.Hexdump#toHexString(int val, int
     * size)} but provides a more practical form when trying to avoid {@link
     * java.lang.String} concatenation and {@link java.lang.StringBuffer}.
     * 
     * @param val
     * @param dst
     * @param dstIndex
     * @param size
     */

    // in the opposite order from how they were added so we need to reverse the list to fulfill our
    // contract.
    // This is somewhat annoying, but turns out to be very fast in practice. Alternatively, we could
    // drop the contract on the method that enforces this queue like behavior since depending on it
    // is likely to be a bug anyway.

 | `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://min.io/docs/minio/linux/reference/minio-mc.html)