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

        api("com.google.code.findbugs:jsr305:3.0.2")
        api("commons-io:commons-io:2.14.0")
        api("commons-lang:commons-lang:2.6")
        api("javax.activation:activation:1.1.1")
        api("javax.xml.bind:jaxb-api:2.3.1")
        api("com.sun.xml.bind:jaxb-core:2.2.11")
        api("com.sun.xml.bind:jaxb-impl:2.2.11")
        api("junit:junit:4.13.2")
        api("org.spockframework:spock-core:$spockVersion")

//
// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
// ```
//
// No matter which of the three exponent forms is used, no quantity may represent
// a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal
// places. Numbers larger or more precise will be capped or rounded up.
// (E.g.: 0.1m will rounded up to 1m.)

            }
            finally {
                f.delete();
            }
        }
    }


    /**
     * @author Ilan Goldfeld
     */
    // #261
    @Test
    public void testExistsOnLock () throws IOException {
        try ( SmbFile f = createTestFile();
              SmbFileOutputStream ostream = f.openOutputStream(true, SmbConstants.FILE_NO_SHARE);

  /** Bitmask that selects the low bits of metadata to get hashTableBits. */
  static final int HASH_TABLE_BITS_MASK = (1 << HASH_TABLE_BITS_MAX_BITS) - 1;

  /** Maximum size of a compact hash-based collection (2^30 - 1 because 0 is UNSET). */
  static final int MAX_SIZE = Ints.MAX_POWER_OF_TWO - 1;

  /** Default size of a compact hash-based collection. */
  static final int DEFAULT_SIZE = 3;

  /**

   *
   * @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
   */

    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,

      /*
       * 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;

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

   *
   * @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
   */