testRotate(new float[] {1}, 0, 0, 1, new float[] {1});
    testRotate(new float[] {1}, 1, 0, 1, new float[] {1});
    testRotate(new float[] {1}, 1, 1, 1, new float[] {1});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6});
    testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6});

    testRotate(new int[] {1}, 0, 0, 1, new int[] {1});
    testRotate(new int[] {1}, 1, 0, 1, new int[] {1});
    testRotate(new int[] {1}, 1, 1, 1, new int[] {1});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(new int[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new int[] {0, 2, 3, 4, 5, 1, 6});
    testRotate(new int[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new int[] {0, 2, 3, 4, 5, 1, 6});

    testRotate(new float[] {1}, 0, 0, 1, new float[] {1});
    testRotate(new float[] {1}, 1, 0, 1, new float[] {1});
    testRotate(new float[] {1}, 1, 1, 1, new float[] {1});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6});
    testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6});

		// considered as Delete marker true to avoid listing such objects by
		// regular ListObjects() calls. However for delete replication this
		// ends up being a problem because "upon" a successful delete this
		// ends up creating a new delete marker that is spurious and unnecessary.
		//
		// Regression introduced by #14555 was reintroduced in #15564
		if versionFound {

  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private void addPendingString(StringBuilder builder) {
    // Capture current builder length so it can be truncated if this future ends up completing while
    // the toString is being calculated
    int truncateLength = builder.length();

    builder.append("PENDING");

    @RetainedLocalRef Object localValue = value();

      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance
   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Longs.asList(array),
   * distance)}, but is considerably faster and avoids allocation and garbage collection.
   *

     * character matches any number of characters in part of a name. If
     * the expression begins with one or more '?'s then exactly that
     * many characters will be matched whereas if it ends with '?'s
     * it will match that many characters <i>or less</i>.
     * <p>
     * Wildcard expressions will not filter workgroup names or server names.
     *
     * @param wildcard the wildcard pattern to match

// ReadLine. ReadLine either returns a non-nil line or it returns an error,
// never both.
//
// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
// No indication or error is given if the input ends without a final line end.
// Calling [Reader.UnreadByte] after ReadLine will always unread the last byte read
// (possibly a character belonging to the line end) even if that byte is not
// part of the line returned by ReadLine.

     */
    protected static Dfs dfs;

    NtlmPasswordAuthentication auth; // Cannot be null
    SmbTree tree = null; // Initially null
    String unc; // Initially null; set by getUncPath; never ends with '/'
    int fid; // Initially 0; set by open()
    int type;
    boolean opened;
    int tree_num;

    /**
     * Constructs an SmbFile representing a resource on an SMB network such as

    // being resumed. To avoid a flake in this scenario, calculate how long that thread actually
    // waited and assert based on that time. Empirically, the race where the thread ends up waiting
    // for 5.5 seconds happens about 2% of the time.
    boolean longWait = NANOSECONDS.toSeconds(thread.timeSpentBlocked) >= 5;