}

  @Test fun clientIncompleteControlFrameBodyThrows() {
    data.write("8a0548656c".decodeHex()) // Length = 5, "Hel"
    assertFailsWith<EOFException> {
      clientReader.processNextFrame()
    }
  }

  @Test fun serverIncompleteMessageBodyThrows() {
    data.write("818537fa213d7f9f4d".decodeHex()) // Length = 5, "Hel"
    assertFailsWith<EOFException> {
      serverReader.processNextFrame()
    }
  }

        byte[] javaChecksum;
        if ( keybytes.length == 16 ) {
            javaChecksum = sun.security.krb5.internal.crypto.Aes128.calculateChecksum(keybytes, usage, bytes, 0, bytes.length);

        }
        else {
            javaChecksum = sun.security.krb5.internal.crypto.Aes256.calculateChecksum(keybytes, usage, bytes, 0, bytes.length);
        }

            this.extraSids = new SID[extraSidAtts.length];
            for ( int i = 0; i < extraSidAtts.length; i++ ) {
                this.extraSids[ i ] = extraSidAtts[ i ].getId();
            }

            // Compute Resource Group IDs with Resource Domain ID to get SIDs
            this.resourceGroupSids = new SID[resourceGroups.length];
            for ( int i = 0; i < resourceGroups.length; i++ ) {

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

    @Override
    public Iterable<Entry<Country, String>> order(List<Entry<Country, String>> insertionOrder) {
      return insertionOrder;
    }

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

    @Override

    int oldCapacity = entries.length;
    entries = Arrays.copyOf(entries, newCapacity);
    if (newCapacity > oldCapacity) {
      Arrays.fill(entries, oldCapacity, newCapacity, UNSET);
    }
    this.entries = entries;
  }

  private void resizeTable(int newCapacity) { // newCapacity always a power of two
    int[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity >= MAXIMUM_CAPACITY) {

            final String[] values = sort.split("\\.");
            final boolean asc;
            if (values.length > 1) {
                asc = !"desc".equalsIgnoreCase(values[1]);
            } else {
                asc = true;
            }
            if (values.length > 0) {
                if ("term".equals(values[0]) || "key".equals(values[0])) {
                    return BucketOrder.key(asc);

    protected String doBuildColumnString(String dm) {
        StringBuilder sb = new StringBuilder();
        sb.append(dm).append(createdAt);
        sb.append(dm).append(updatedAt);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================

      int remaining = input.remaining();
      if (count + remaining > buf.length) {
        buf = Arrays.copyOf(buf, count + remaining);
      }
      input.get(buf, count, remaining);
      count += remaining;
    }

    byte[] byteArray() {
      return buf;
    }

    int length() {
      return count;
    }
  }

     */
    public HMACT64(byte[] key) {
        super("HMACT64");
        int length = Math.min(key.length, BLOCK_LENGTH);
        for (int i = 0; i < length; i++) {
            ipad[i] = (byte) (key[i] ^ IPAD);
            opad[i] = (byte) (key[i] ^ OPAD);
        }
        for (int i = length; i < BLOCK_LENGTH; i++) {
            ipad[i] = IPAD;
            opad[i] = OPAD;
        }
        try {

     */
    public HMACT64 ( byte[] key ) {
        super("HMACT64");
        int length = Math.min(key.length, BLOCK_LENGTH);
        for ( int i = 0; i < length; i++ ) {
            this.ipad[ i ] = (byte) ( key[ i ] ^ IPAD );
            this.opad[ i ] = (byte) ( key[ i ] ^ OPAD );
        }
        for ( int i = length; i < BLOCK_LENGTH; i++ ) {
            this.ipad[ i ] = IPAD;
            this.opad[ i ] = OPAD;