byte[] derived = new byte[length];

        // Combine inputs
        byte[] labelBytes = label.getBytes(java.nio.charset.StandardCharsets.UTF_8);
        byte[] input = new byte[baseKey.length + labelBytes.length + (context != null ? context.length : 0)];

        int pos = 0;
        System.arraycopy(baseKey, 0, input, pos, baseKey.length);
        pos += baseKey.length;

  public final Entry<String, String>[] createArray(int length) {
    return (Entry<String, String>[]) new Entry<?, ?>[length];
  }

  @Override
  public final String[] createKeyArray(int length) {
    return new String[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override

      }
      Arrays.fill(sortedElements, uniques, length, null);
      if (maybeExpand && uniques * 4 > length * 3) {
        // lots of nonduplicated elements, expand the array by 50%
        sortedElements =
            Arrays.copyOf(sortedElements, IntMath.saturatedAdd(length, length / 2 + 1));
      }
      int[] sortedCounts = new int[sortedElements.length];
      for (int i = 0; i < length; i++) {

     * @param length the number of bytes to dump from the source array
     */

    public static void hexdump(final PrintStream ps, final byte[] src, final int srcIndex, final int length) {
        if (length == 0) {
            return;
        }

        final int s = length % 16;
        final int r = s == 0 ? length / 16 : length / 16 + 1;
        final char[] c = new char[r * (74 + NL_LENGTH)];

        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

        // Encode from first instance
        byte[] encodedBuffer = new byte[22];
        firstInstance.encode(encodedBuffer, 0);

        // Decode into second instance
        FileStandardInfo secondInstance = new FileStandardInfo();
        secondInstance.decode(encodedBuffer, 0, encodedBuffer.length);

        // Verify both instances have same values

            when(mockBuffer.dec_ndr_short()).thenReturn(100) // length
                    .thenReturn(0); // auth_value length

            message.decode_header(mockBuffer);

            assertEquals(DcerpcConstants.RPC_PT_RESPONSE, message.ptype);
            assertEquals(DcerpcConstants.RPC_C_PF_BROADCAST, message.flags);
            assertEquals(100, message.length);
            assertEquals(123, message.call_id);
        }

        byte[] actualDescrBytes = new byte[expectedDescrBytes.length];
        System.arraycopy(dst, 2, actualDescrBytes, 0, expectedDescrBytes.length);
        assertArrayEquals(expectedDescrBytes, actualDescrBytes);

        // Verify level (0x0001)
        int descrEnd = 2 + expectedDescrBytes.length;
        assertEquals(0x01, dst[descrEnd]);
        assertEquals(0x00, dst[descrEnd + 1]);

        System.arraycopy(mac, 0, ret, 0, mac.length);
        System.arraycopy(clientData, 0, ret, mac.length, clientData.length);
        return ret;
    }

    /**
     * Generates the NTOWFv2 hash for the given domain, username, and password.
     *
     * @param domain the authentication domain
     * @param username the username
     * @param password the password
     *

        final int length = src != null ? src.length : 0;
        if (length == 0) {
            return;
        }
        writeUShort(dest, offset, length);
        writeUShort(dest, offset + 2, length);
        writeULong(dest, offset + 4, bodyOffset);
        System.arraycopy(src, 0, dest, bodyOffset, length);
    }

    static String getOEMEncoding() {

            } else {
                // backward compatibility
                final int length = spaceStr.length();
                spaceChars = new int[length];
                for (int i = 0; i < length; i++) {
                    spaceChars[i] = spaceStr.codePointAt(i);
                }
            }
            propMap.put(key, spaceChars);
        }