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

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

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

    testRotate(new char[] {'1', '2', '3', '4'}, -9, new char[] {'2', '3', '4', '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});

    assertNextPermutation(newArrayList(3, 2, 1, 4), permutations);

    assertNextPermutation(newArrayList(2, 3, 1, 4), permutations);
    assertNextPermutation(newArrayList(2, 3, 4, 1), permutations);
    assertNextPermutation(newArrayList(2, 4, 3, 1), permutations);
    assertNextPermutation(newArrayList(4, 2, 3, 1), permutations);

    assertNextPermutation(newArrayList(4, 2, 1, 3), permutations);

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

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