void testEncodeIdempotency() {
            String path = "\\\\server\\share";
            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst1 = new byte[buffer.size()];
            byte[] dst2 = new byte[buffer.size()];

            int bytesEncoded1 = buffer.encode(dst1, 0);
            int bytesEncoded2 = buffer.encode(dst2, 0);

            assertEquals(bytesEncoded1, bytesEncoded2);

        byte[] buffer = new byte[256];
        int written = trans2FindNext2.writeParametersWireFormat(buffer, 0);

        assertEquals(0, SMBUtil.readInt2(buffer, 0)); // sid
        assertEquals(0, SMBUtil.readInt2(buffer, 2)); // maxItems
        assertEquals(0, SMBUtil.readInt4(buffer, 6)); // resumeKey
    }

    // Helper method to read string from buffer

        byte[] buffer = new byte[256];

        // Perform multiple operations
        for (int i = 0; i < 5; i++) {
            trans2QueryFSInfo.writeSetupWireFormat(buffer, 0);
            trans2QueryFSInfo.writeParametersWireFormat(buffer, 0);
            trans2QueryFSInfo.writeDataWireFormat(buffer, 0);
            trans2QueryFSInfo.readSetupWireFormat(buffer, 0, buffer.length);

//     specified number of elements. The size may be omitted, in which case
//     a small starting size is allocated.
//   - Channel: The channel's buffer is initialized with the specified
//     buffer capacity. If zero, or the size is omitted, the channel is
//     unbuffered.
func make(t Type, size ...IntegerType) Type

// The max built-in function returns the largest value of a fixed number of

        this.flags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // LeaseKey (16 bytes)
        byte[] keyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, keyBytes, 0, 16);
        this.leaseKey = new Smb2LeaseKey(keyBytes);
        bufferIndex += 16;

        // LeaseState (4 bytes)
        this.leaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

                // Simulate header reading
                return 33;
            }
        };
        byte[] buffer = new byte[1024];

        // Setup buffer after header
        buffer[33] = 4; // wordCount
        buffer[34] = (byte) 0xFF; // andxCommand
        buffer[36] = 0; // andxOffset low
        buffer[37] = 0; // andxOffset high

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        bufferIndex += 2; // reserved
        dataCompactionMode = readInt2(buffer, bufferIndex);
        bufferIndex += 4; // 2 reserved
        dataLength = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 12; // 10 reserved

            assertEquals(100L, SMBUtil.readInt8(buffer, 0));
            assertEquals(200L, SMBUtil.readInt8(buffer, 8));
            assertEquals(300, SMBUtil.readInt4(buffer, 16));

            // Verify second chunk
            assertEquals(400L, SMBUtil.readInt8(buffer, EXPECTED_SIZE));
            assertEquals(500L, SMBUtil.readInt8(buffer, EXPECTED_SIZE + 8));

        return 0;
    }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override

	v := metacache{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodemetacache(b *testing.B) {
	v := metacache{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))