testRotate(new int[] {1, 2, 3}, 3, new int[] {1, 2, 3});
    testRotate(new int[] {1, 2, 3}, 4, new int[] {3, 1, 2});
    testRotate(new int[] {1, 2, 3}, 5, new int[] {2, 3, 1});

    testRotate(new int[] {1, 2, 3, 4}, -9, new int[] {2, 3, 4, 1});
    testRotate(new int[] {1, 2, 3, 4}, -5, new int[] {2, 3, 4, 1});
    testRotate(new int[] {1, 2, 3, 4}, -1, new int[] {2, 3, 4, 1});

    X345,
    X346,
    X347,
    X348,
    X349,
    X350,
    X351,
    X352,
    X353,
    X354,
    X355,
    X356,
    X357,
    X358,
    X359,
    X360,
    X361,
    X362,
    X363,
    X364,
    X365,
    X366,
    X367,
    X368,
    X369,
    X370,
    X371,
    X372,
    X373,
    X374,
    X375,
    X376,
    X377,

    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];
    rng.nextBytes(bytes);
    assertEquals(hashFunction.hashBytes(bytes), hashFunction.hashBytes(ByteBuffer.wrap(bytes)));
  }

  static void assertHashByteBufferExhaustsBuffer(HashFunction hashFunction) {
    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];
    rng.nextBytes(bytes);

      /*
       * Use 16 bits per entry. The value is unsigned to allow use up to a size of 2^16.
       *
       * The absent indicator of -1 signed becomes 2^16 - 1 unsigned, which reduces the actual max
       * size to 2^16 - 1. However, due to a load factor < 1 the limit is never approached.
       */
      short[] hashTable = new short[tableSize];
      Arrays.fill(hashTable, ABSENT);

      int outI = 0;

   *
   * @since 23.1
   */
  public static void sort(long[] array) {
    checkNotNull(array);
    sort(array, 0, array.length);
  }

  /**
   * Sorts the array between {@code fromIndex} inclusive and {@code toIndex} exclusive, treating its
   * elements as unsigned 64-bit integers.
   *
   * @since 23.1
   */

    testRotate(new double[] {1, 2, 3}, 2, new double[] {2, 3, 1});
    testRotate(new double[] {1, 2, 3}, 3, new double[] {1, 2, 3});
    testRotate(new double[] {1, 2, 3}, 4, new double[] {3, 1, 2});
    testRotate(new double[] {1, 2, 3}, 5, new double[] {2, 3, 1});

    testRotate(new double[] {1, 2, 3, 4}, -9, new double[] {2, 3, 4, 1});
    testRotate(new double[] {1, 2, 3, 4}, -5, new double[] {2, 3, 4, 1});

    testRotate(new long[] {1, 2, 3}, 3, new long[] {1, 2, 3});
    testRotate(new long[] {1, 2, 3}, 4, new long[] {3, 1, 2});
    testRotate(new long[] {1, 2, 3}, 5, new long[] {2, 3, 1});

    testRotate(new long[] {1, 2, 3, 4}, -9, new long[] {2, 3, 4, 1});
    testRotate(new long[] {1, 2, 3, 4}, -5, new long[] {2, 3, 4, 1});
    testRotate(new long[] {1, 2, 3, 4}, -1, new long[] {2, 3, 4, 1});

    testRotate(new short[] {1, 2, 3}, 2, new short[] {2, 3, 1});
    testRotate(new short[] {1, 2, 3}, 3, new short[] {1, 2, 3});
    testRotate(new short[] {1, 2, 3}, 4, new short[] {3, 1, 2});
    testRotate(new short[] {1, 2, 3}, 5, new short[] {2, 3, 1});

    testRotate(new short[] {1, 2, 3, 4}, -9, new short[] {2, 3, 4, 1});
    testRotate(new short[] {1, 2, 3, 4}, -5, new short[] {2, 3, 4, 1});

   *
   * @since 23.1
   */
  public static void sort(int[] array) {
    checkNotNull(array);
    sort(array, 0, array.length);
  }

  /**
   * Sorts the array between {@code fromIndex} inclusive and {@code toIndex} exclusive, treating its
   * elements as unsigned 32-bit integers.
   *
   * @since 23.1
   */

    testRotate(new float[] {1, 2, 3}, 2, new float[] {2, 3, 1});
    testRotate(new float[] {1, 2, 3}, 3, new float[] {1, 2, 3});
    testRotate(new float[] {1, 2, 3}, 4, new float[] {3, 1, 2});
    testRotate(new float[] {1, 2, 3}, 5, new float[] {2, 3, 1});

    testRotate(new float[] {1, 2, 3, 4}, -9, new float[] {2, 3, 4, 1});
    testRotate(new float[] {1, 2, 3, 4}, -5, new float[] {2, 3, 4, 1});