@DisplayName("Test buffer management")
    void testBufferManagement() {
        byte[] buffer = new byte[1024];
        buffer[0] = 0x42;

        transaction.setBuffer(buffer);

        byte[] released = transaction.releaseBuffer();
        assertSame(buffer, released);
        assertEquals(0x42, released[0]);

        // After release, getting buffer again should return null
        assertNull(transaction.releaseBuffer());

            originalUuid.clock_seq_hi_and_reserved = (byte) 0x99;
            originalUuid.clock_seq_low = (byte) 0x88;
            originalUuid.node = new byte[] { (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 };

            // Mock encoding buffer
            NdrBuffer encodeBuffer = mock(NdrBuffer.class);
            when(encodeBuffer.derive(anyInt())).thenReturn(encodeBuffer);

    // "\u024B62\u024B62"
    assertWellFormed(0xc9, 0x8b, 0x36, 0x32, 0xc9, 0x8b, 0x36, 0x32);
    // Mixed string
    // "a\u020ac\u00a2b\\u024B62u020acc\u00a2de\u024B62"
    assertWellFormed(
        0x61, 0xc8, 0x8a, 0x63, 0xc2, 0xa2, 0x62, 0x5c, 0x75, 0x30, 0x32, 0x34, 0x42, 0x36, 0x32,
        0x75, 0x30, 0x32, 0x30, 0x61, 0x63, 0x63, 0xc2, 0xa2, 0x64, 0x65, 0xc9, 0x8b, 0x36, 0x32);
    // Not a valid string

		f:      formatZstd,
	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4
		header: []byte{0x4, 0x22, 0x4d, 0x18},
		f:      formatLZ4,
	},
	{
		// Snappy/S2 stream
		header: []byte{0xff, 0x06, 0x00, 0x00},
		f:      formatS2,
	},
	{
		header: []byte{0x42, 0x5a, 'h'},
		f:      formatBZ2,
	},
}

type untarOptions struct {

      0x1ffc,
      0x3ffc,
      0x22,
      0x7ffd,
      0x3,
      0x23,
      0x4,
      0x24,
      0x5,
      0x25,
      0x26,
      0x27,
      0x6,
      0x74,
      0x75,
      0x28,
      0x29,
      0x2a,
      0x7,
      0x2b,
      0x76,
      0x2c,
      0x8,
      0x9,
      0x2d,
      0x77,
      0x78,
      0x79,

    void testEncodeWithAndxBatchingEnabled() {
        when(mockConfig.isUseBatching()).thenReturn(true);
        when(mockAndxCommand.getCommand()).thenReturn(0x42);

        TestAndXServerMessageBlock andxBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x42);
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25, andxBlock);
        testBlock.batchLevel = 0;

            Type2Message message = new Type2Message(mockContext);
            byte[] testContext =
                    new byte[] { (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66, (byte) 0x77, (byte) 0x88 };

            // When
            message.setContext(testContext);

            // Then
            assertArrayEquals(testContext, message.getContext());
        }

        int keyLen = Math.min(key.length, 64);
        for (int i = 0; i < keyLen; i++) {
            ipad[i] = (byte) (key[i] ^ 0x36);
            opad[i] = (byte) (key[i] ^ 0x5c);
        }
        for (int i = keyLen; i < 64; i++) {
            ipad[i] = 0x36;
            opad[i] = 0x5c;
        }

        // Calculate inner hash
        md5.reset();
        md5.update(ipad);

	// map header, size 4
	// write "NEndpoints"
	err = en.Append(0x84, 0xaa, 0x4e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.NEndpoints)
	if err != nil {
		err = msgp.WrapError(err, "NEndpoints")
		return
	}
	// write "CmdLines"
	err = en.Append(0xa8, 0x43, 0x6d, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x73)
	if err != nil {
		return
	}

        serverData.serverTime = System.currentTimeMillis();
        serverData.serverTimeZone = -480; // PST
        serverData.encryptionKeyLength = 8;
        serverData.encryptionKey = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88 };
        serverData.guid = new byte[16];

        // Then - verify all values are set correctly
        assertEquals((byte) 0x98, serverData.sflags);