// Decode into first instance
        FileStandardInfo firstInstance = new FileStandardInfo();
        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

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

        // Decode into second instance

        byte[] buffer1 = new byte[request.size()];
        byte[] buffer2 = new byte[request.size()];

        request.encode(buffer1, 0);
        request.encode(buffer2, 0);

        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test encode with insufficient buffer throws exception")
    void testEncodeWithInsufficientBuffer() {
        ValidateNegotiateInfoRequest request =

        return src[si] & 0xFF | (src[si + 1] & 0xFF) << 8 | (src[si + 2] & 0xFF) << 16 | (src[si + 3] & 0xFF) << 24;
    }

    /* Encode and decode 64 bit integers
     */

    /**
     * Encodes a 64-bit unsigned integer in big-endian byte order.
     *
     * @param l the long value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array

	v := ActiveWorkerStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := ActiveWorkerStat{}
	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)

	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := BucketReplicationResyncStatus{}
	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 {

    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */
    @Test
    void decodeFromEncodedBuffer() throws NdrException {
        NdrShort ns = new NdrShort(123); // masked value 123 (already fits in 8 bits)
        buf.reset();
        ns.encode(buf);

        // Reset buffer to start for decoding
        buf.reset();

        // When
        int encoded = messageBlock.encode(buffer, encodeIndex);
        int decoded = messageBlock.decode(buffer, decodeIndex);

        // Then
        assertEquals(encodeLength, encoded);
        assertEquals(decodeLength, decoded);
        verify(messageBlock).encode(buffer, encodeIndex);
        verify(messageBlock).decode(buffer, decodeIndex);
    }

		ID:        "uuid",
		Error:     "",
	}

	var buf bytes.Buffer
	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {
		dec := gob.NewDecoder(bytes.NewBuffer(encoded))
		err := dec.Decode(&v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncodeDiskInfoMsgp(b *testing.B) {

            byte[] largeBuffer = new byte[1000];

            // Act
            int smallEncodedSize = context.encode(smallBuffer, 0);
            int largeEncodedSize = context.encode(largeBuffer, 500);

            // Assert
            // encode() returns actual bytes written (6), not size() value (8)
            assertEquals(6, smallEncodedSize); // actual: 2 bytes count + 2*2 bytes for ciphers

        // Encode to buffer
        byte[] buffer = new byte[1024];
        NdrBuffer encodeBuffer = new NdrBuffer(buffer, 0);
        domainInfo.encode(encodeBuffer);

        // Decode from buffer
        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);
        lsarpc.LsarDomainInfo decodedInfo = new lsarpc.LsarDomainInfo();
        decodedInfo.decode(decodeBuffer);