long b = (high ^ a) * K3;
    b ^= b >>> 47;
    b *= K3;
    return b;
  }

  /**
   * Computes intermediate hash of 32 bytes of byte array from the given offset. Results are
   * returned in the output array - this is 12% faster than allocating new arrays every time.
   */
  private static void weakHashLength32WithSeeds(
      byte[] bytes, int offset, long seedA, long seedB, long[] output) {

  private static void testSortDescending(byte[] input, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    SignedBytes.sortDescending(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testSortDescending(
      byte[] input, int fromIndex, int toIndex, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    SignedBytes.sortDescending(input, fromIndex, toIndex);

    }

    @Test(expected = IllegalArgumentException.class)
    public void testGetAsListWithArray() {
        // Test with array (should throw exception)
        String[] array = { "one", "two" };
        SuggestUtil.getAsList(array);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testGetAsListWithDouble() {
        // Test with double (should throw exception)

        verify(consumer, times(3)).accept(dosCaptor.capture(), ntCaptor.capture());
        assertIterableEquals(Arrays.asList(0x00000000, 0x00050001, 0x007b0001), dosCaptor.getAllValues());
        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

        // And ensure no further interactions happened
        verifyNoMoreInteractions(consumer);

      return standardRetainAll(collection);
    }

    @Override
    public Object[] toArray() {
      return standardToArray();
    }

    @Override
    public <T> T[] toArray(T[] array) {
      return standardToArray(array);
    }

    @Override
    public String toString() {
      return standardToString();
    }
  }

            // Should only copy first 16 bytes
            assertArrayEquals(Arrays.copyOfRange(longFileId, 0, 16), Arrays.copyOfRange(buffer, 16, 32));
        }

        @Test
        @DisplayName("Should handle file ID shorter than 16 bytes")
        void testShortFileId() {
            byte[] shortFileId = new byte[8];
            Arrays.fill(shortFileId, (byte) 0xAB);
            request.setFileId(shortFileId);

      }
      Class<?> returnType = method.getReturnType();
      assertTrue(
          rootLocaleFormat("%s.%s() must return an array.", annotationClass, propertyName),
          returnType.isArray());
      assertWithMessage(
              rootLocaleFormat(
                  "%s.%s() must return an array of %s.",
                  annotationClass, propertyName, annotationClass.getDeclaringClass()))
          .that(returnType.getComponentType())

     */
    private void traverseTest(
        RestTestContext testContext,
        JsonNode currentNode,
        String parentKeyName,
        Map<String, List<RestTestTransformByParentObject>> objectKeyFinders,
        Map<String, List<RestTestTransformByParentArray>> arrayByObjectKeyFinders
    ) {
        if (currentNode.isArray()) {
            if (parentKeyName != null) {

    }

    @Test
    @DisplayName("readUShort throws on too short array")
    void testReadUShortOutOfBounds() {
        byte[] a = new byte[] { 0x02 };
        assertThrows(IndexOutOfBoundsException.class, () -\u003e NtlmMessage.readUShort(a, 0));
    }

    @Test
    @DisplayName("readULong throws on too short array")
    void testReadULongOutOfBounds() {
        byte[] a = new byte[] { 0x01, 0x02, 0x03 };

        assertArrayEquals(plaintext, decrypted1);
        assertArrayEquals(plaintext, decrypted2);

        // Clean up
        Arrays.fill(plaintext, '\0');
        Arrays.fill(decrypted1, '\0');
        Arrays.fill(decrypted2, '\0');
    }

    @Test
    public void testBase64StringOperations() throws Exception {
        char[] plaintext = "TestPassword456".toCharArray();