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;

        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();

        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());

    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) {

                .computeIfAbsent(getClass().getName() + ".relocations", () -> parseRelocations(session));
        if (relocations != null) {
            Artifact original = artifactDescriptorResult.getRequest().getArtifact();
            Relocation relocation = relocations.getRelocation(original);
            if (relocation != null
                    && (isProjectContext(artifactDescriptorResult.getRequest().getRequestContext())

  }

  public void testCreateFromHashMultimap() {
    Multimap<String, Integer> original = HashMultimap.create();
    ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create(original);
    assertEquals(3, multimap.expectedValuesPerKey);
  }

  public void testCreateFromArrayListMultimap() {
    ArrayListMultimap<String, Integer> original = ArrayListMultimap.create(15, 20);