return dstIndex - start;
    }

    /**
     * Decode a transform header from byte array
     *
     * @param buffer
     *            buffer to decode from
     * @param bufferIndex
     *            offset in buffer
     * @return new transform header instance
     */
    public static Smb2TransformHeader decode(final byte[] buffer, int bufferIndex) {

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecoderebalanceInfo Msgsize() is inaccurate")
	}

	vn := rebalanceInfo{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

        int encodedSize = context.encode(buffer, 0);

        // Create new context for decoding
        CompressionNegotiateContext decodedContext = new CompressionNegotiateContext();
        int decodedSize = decodedContext.decode(buffer, 0, encodedSize);

        assertEquals(encodedSize, decodedSize);
        assertArrayEquals(context.getCompressionAlgorithms(), decodedContext.getCompressionAlgorithms());

        // Test encode
        int encodeLength = transaction.encode(buffer, 0);
        assertTrue(encodeLength > 0);

        // Test decode - should not throw exception
        assertDoesNotThrow(() -> {
            transaction.decode(buffer, 0);
        });
    }

    @Test
    @DisplayName("Test configuration usage")
    void testConfigurationUsage() {
        // Verify configuration is used

    /**
     * Create a new durable handle V2 response
     */
    public DurableHandleV2Response() {
        // Will be populated during decode
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {

* the cloud service

* the development
* the development stages

* the dict
* the dictionary
* the enumeration
* the enum
* the enum member

* the encoder
* the decoder
* to encode
* to decode

* the exception
* to raise

* the expression
* the statement

* the frontend
* the backend

* the GitHub discussion
* the GitHub issue

* the performance

          // otherwise try to presize a StringBuilder
          // it is kind of lame that we need to construct a decoder to access this value.
          // if this is a concern we could add special cases for some known charsets (like utf8)
          // or we could avoid inputstreamreader and use the decoder api directly
          // TODO(lukes): in a real implementation we would need to handle overflow conditions

	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBucketReplicationStat Msgsize() is inaccurate")
	}

	vn := BucketReplicationStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

            this.unlocks[i] = createLockRange();
            bufferIndex += this.unlocks[i].decode(buffer, bufferIndex, buffer.length);
        }

        for (int i = 0; i < this.locks.length; i++) {
            this.locks[i] = createLockRange();
            bufferIndex += this.locks[i].decode(buffer, bufferIndex, buffer.length);
        }

        return start - bufferIndex;
    }

    /**

    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += UnsignedLongs.decode(decimalStrings[j]);
    }
    return tmp;
  }

  @Benchmark
  long parseDecode16(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += UnsignedLongs.decode(prefixedHexStrings[j]);
    }
    return tmp;
  }

  @Benchmark