byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

        assertEquals(0x01FFFF, length);
    }

    @Test
    @DisplayName("readLength should handle zero length")
    void testReadLengthZero() {
        byte[] src = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

     */
    @Test
    void testConstructorWithMalformedKerberosToken() throws IOException {
        byte[] malformedToken = createGssApiWrapper(new ASN1ObjectIdentifier(KerberosConstants.KERBEROS_OID), new byte[] { 0x00, 0x00 });
        assertThrows(PACDecodingException.class, () -> new KerberosToken(malformedToken));
    }

    /**
     * Test constructor with missing APPLICATION tag in the token.
     *

# ADR-0002 - Avoid using Java serialization

## Status

- ACCEPTED on 2023-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

        message[57] = 0;
        message[58] = 0;
        message[59] = 0;

        // Flags (NTLMSSP_NEGOTIATE_UNICODE)
        message[60] = 0x01; // NTLMSSP_NEGOTIATE_UNICODE
        message[61] = 0x00;
        message[62] = 0x00;
        message[63] = 0x00;

        // Add dummy LM response (24 zeros at offset 64)
        for (int i = 0; i < 24; i++) {
            message[64 + i] = 0;
        }

        src[srcIndex + 1] = 0x0C; // Pointer offset
        // recordType (2 bytes)
        src[srcIndex + 2] = 0x00;
        src[srcIndex + 3] = 0x20; // NB (0x0020)
        // recordClass (2 bytes)
        src[srcIndex + 4] = 0x00;
        src[srcIndex + 5] = 0x01; // IN (0x0001)
        // ttl (4 bytes)
        src[srcIndex + 6] = 0x00;
        src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;

            buffer[0] = 0x10;
            buffer[1] = 0x00;
            // Share type (DISK)
            buffer[2] = Smb2TreeConnectResponse.SMB2_SHARE_TYPE_DISK;
            // Reserved
            buffer[3] = 0;
            // Share flags (DFS)
            buffer[4] = 0x01;
            buffer[5] = 0x00;
            buffer[6] = 0x00;
            buffer[7] = 0x00;
            // Capabilities (DFS)

        return Stream.of(Arguments.of(0x1234, 0L, new byte[] { 0x34, 0x12, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                // negative fid wraps around, lastWriteTime = 1000 -> 1 second -> int value 1
                Arguments.of(-1, 1000L, new byte[] { (byte) 0xFF, (byte) 0xFF, 0x01, 0x00, 0x00, 0x00 }));
    }

    /**
     * When lastWriteTime is zero the encoded unsigned time must be all 1s.

        // Expected format: buffer format (0x04) + path string (null terminated)
        byte[] expected = new byte[directoryName.length() + 2];
        expected[0] = 0x04; // Buffer format
        System.arraycopy(directoryName.getBytes(StandardCharsets.UTF_8), 0, expected, 1, directoryName.length());
        expected[directoryName.length() + 1] = 0x00; // Null terminator

        byte[] dst = new byte[100];

        // Default constructor
    }

    // session service packet types
    static final int SESSION_MESSAGE = 0x00;
    static final int SESSION_REQUEST = 0x81;

    /**
     * NetBIOS positive session response packet type.
     */
    public static final int POSITIVE_SESSION_RESPONSE = 0x82;

    /**
     * NetBIOS negative session response packet type.
     */

        // Then
        assertTrue(result > 0);
        assertEquals((byte) 0x04, dst[0]); // First buffer format byte

        // Find the second buffer format byte
        int secondBufferFormatIndex = oldFileName.length() + 2; // 1 for first 0x04, 1 for null terminator
        assertEquals((byte) 0x04, dst[secondBufferFormatIndex]);
    }

    /**
     * Test writeBytesWireFormat with Unicode encoding