return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

  private static byte[] combineBuffers(Queue<byte[]> bufs, int totalLen) {
    if (bufs.isEmpty()) {
      return new byte[0];
    }
    byte[] result = bufs.remove();
    if (result.length == totalLen) {
      return result;
    }

     */
    public WitnessUnregisterMessage(byte[] contextHandle) {
        super(WITNESS_UNREGISTER);
        this.contextHandle = contextHandle != null ? contextHandle.clone() : new byte[20];
    }

    /**
     * Sets the context handle for unregistration.
     *
     * @param contextHandle the context handle from registration
     */
    public void setContextHandle(byte[] contextHandle) {

        dst[di] = (byte) (i & 0xFF);
        di++;
        dst[di++] = (byte) (i >> 8 & 0xFF);
        dst[di++] = (byte) (i >> 16 & 0xFF);
        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /*
     * Decode integers
     */

    /**
     * Decodes a 16-bit unsigned integer from big-endian byte order.
     *

        private final byte[] salt;
        private final int hashAlgorithm;
        private volatile byte[] currentHash;
        private volatile boolean isValid;
        private final Object hashLock = new Object();

        public PreauthIntegrityContext(byte[] salt, int hashAlgorithm) {
            this.salt = salt != null ? salt.clone() : new byte[0];
            this.hashAlgorithm = hashAlgorithm;

        byte[] dst = new byte[10];
        // The method should not write anything and return 0
        assertEquals(0, response.writeDataWireFormat(dst, 0), "writeDataWireFormat should return 0.");
    }

    /**
     * Test for the readSetupWireFormat method.
     * It should always return 0.
     */
    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];

    hasher = HASH_FN.newHasher();
    hasher
        .putByte((byte) 0x01)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();

        super(config);
        this.data = b;
        this.offset = off;
    }

    void setParam(final byte[] b, final int off) {
        this.data = b;
        this.offset = off;
    }

    /**
     * Gets the read data buffer.
     *
     * @return the read data
     */
    public final byte[] getData() {
        return this.data;
    }

        @Test
        @DisplayName("Should encode at different buffer positions")
        void testEncodeAtDifferentPositions() {
            int[] hashAlgos = { 1, 2 };
            byte[] salt = new byte[8];
            Arrays.fill(salt, (byte) 0xFF);

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode at position 100

	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RMetricName) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RMetricName) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)

        maxDataCount = 800;
        maxSetupCount = 0;
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        return 2;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        writeInt2(informationLevel, dst, dstIndex);