*            Message
     * @param cause
     *            The original exception
     */
    public ClIllegalStateException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a {@link ClIllegalStateException}.
     *
     * @param cause
     *            The original exception
     */
    public ClIllegalStateException(final Throwable cause) {

public class NdrHyperTest {

    /**
     * Tests a simple round‑trip encode → decode retains the original value.
     */
    @Test
    @DisplayName("Basic round‑trip for a fixed value")
    public void testEncodeRoundTrip() throws NdrException {
        final long original = 0x1122334455667788L;
        NdrHyper hyper = new NdrHyper(original);
        // Create buffer with extra space for alignment

        String fileName = "roundtrip_test.txt";
        boolean replaceIfExists = true;

        FileRenameInformation2 original = new FileRenameInformation2(fileName, replaceIfExists);

        // Encode
        byte[] buffer = new byte[200];
        int bytesWritten = original.encode(buffer, 0);

        // Decode
        FileRenameInformation2 decoded = new FileRenameInformation2();

Platform.stringIsNullOrEmpty = function(str) {
  return !str;
};


/**
 * @param {?string} str
 * @return {string} Original str, if it is non-null. Otherwise empty string.
 */
Platform.nullToEmpty = function(str) {
  return str || "";
};


/**
 * @param {?string} str
 * @return {string} Original str, if it is non-empty. Otherwise null;
 */
Platform.emptyToNull = function(str) {
  return str || null;

        SmbOperationException original = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_TIMEOUT, "Timeout");
        original.withContext("attempt", 1);

        // When
        SmbOperationException retry = SmbOperationException.forRetry(original, 2);

        // Then
        assertEquals(original.getErrorCode(), retry.getErrorCode());
        assertEquals(original.getMessage(), retry.getMessage());

        long originalValue = 0x123456789ABCDEFL;
        FileEndOfFileInformation original = new FileEndOfFileInformation(originalValue);

        // Encode
        byte[] buffer = new byte[8];
        int encoded = original.encode(buffer, 0);
        assertEquals(8, encoded);

        // Decode
        FileEndOfFileInformation decoded = new FileEndOfFileInformation();

    super(false, false, false, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, Character> table = HashBasedTable.create();

 * the result (if successful), and any error that occurred during processing.
 * <p>
 * This class is immutable and thread-safe, suitable for use in concurrent operations.
 *
 * @param <REQ> The type of the request
 * @param <REP> The type of the response, which must extend {@code Result<REQ>}
 * @param request The original request that was processed

expanded_policy_count=$(./mc admin policy list myminio/ | wc -l)

if [ $user_count -ne $expanded_user_count ]; then
	echo "BUG: original user count differs from expanded setup"
	exit 1
fi

if [ $policy_count -ne $expanded_policy_count ]; then
	echo "BUG: original policy count  differs from expanded setup"
	exit 1
fi

./mc version info myminio/versioned | grep -q "versioning is enabled"
ret=$?

        this.maxRetries = maxRetries;
        this.retryDelay = retryDelay;
    }

    /**
     * Attempt to reconnect a handle
     * @param path the file path
     * @param cause the original exception that triggered reconnection
     * @return a future that completes with the reconnected handle info or fails
     */
    public CompletableFuture<HandleInfo> reconnectHandle(String path, Exception cause) {