}
    }

    /**
     * Get handle information by GUID
     * @param guid the handle GUID
     * @return the handle info or null if not found
     */
    public HandleInfo getHandleByGuid(HandleGuid guid) {
        lock.readLock().lock();
        try {
            return guidToHandle.get(guid);
        } finally {
            lock.readLock().unlock();
        }
    }

        assertNotNull(response.getServerGuid(), "Server GUID should not be null");
        assertEquals(16, response.getServerGuid().length, "Server GUID should be 16 bytes");
        assertArrayEquals(new byte[16], response.getServerGuid(), "Initial server GUID should be all zeros");
        assertEquals(0, response.getSecurityMode(), "Initial security mode should be 0");

        }
    }

    @Test
    public void testRequestDurableHandle() {
        HandleGuid guid = manager.requestDurableHandle("/test/file.txt", HandleType.DURABLE_V2, 120000, null);

        assertNotNull(guid);
        assertEquals(1, manager.getHandleCount());

        HandleInfo info = manager.getHandleByGuid(guid);
        assertNotNull(info);
        assertEquals("/test/file.txt", info.getPath());

    /**
     * Create new handle information
     * @param path the file path
     * @param guid the create GUID
     * @param fileId the 16-byte file ID
     * @param type the handle type
     * @param timeout the timeout in milliseconds
     * @param leaseKey the associated lease key (can be null)
     */
    public HandleInfo(String path, HandleGuid guid, byte[] fileId, HandleType type, long timeout, Smb2LeaseKey leaseKey) {
        this.path = path;

        }
        ByteBuffer bb = ByteBuffer.wrap(bytes);
        long mostSig = bb.getLong();
        long leastSig = bb.getLong();
        this.guid = new UUID(mostSig, leastSig);
    }
    
    public byte[] toBytes() {
        ByteBuffer bb = ByteBuffer.allocate(16);
        bb.putLong(guid.getMostSignificantBits());
        bb.putLong(guid.getLeastSignificantBits());

        int caps = SMBUtil.readInt4(buffer, 8);
        assertTrue((caps & Smb2Constants.SMB2_GLOBAL_CAP_DFS) != 0);

        // Verify client GUID
        byte[] guid = new byte[16];
        System.arraycopy(buffer, 12, guid, 0, 16);
        assertArrayEquals(testMachineId, guid);

        // Verify dialects
        assertEquals(0x0210, SMBUtil.readInt2(buffer, 36));
        assertEquals(0x0300, SMBUtil.readInt2(buffer, 38));

        response.byteCount = 16; // GUID length

        // Prepare byte array with a GUID
        byte[] guid = new byte[16];
        for (int i = 0; i < 16; i++) {
            guid[i] = (byte) i;
        }

        // Call the method
        int bytesRead = response.readBytesWireFormat(guid, 0);

        // Assertions

        assertNotEquals(guid1, null);
        assertNotEquals(guid1, "not a guid");
    }

    @Test
    public void testHandleGuidToString() {
        UUID uuid = UUID.randomUUID();
        HandleGuid guid = new HandleGuid(uuid);

        assertEquals(uuid.toString(), guid.toString());
    }

        this.createGuid = new HandleGuid();
    }

    /**
     * Create a new durable handle V2 request with specific GUID
     * @param timeoutMs the timeout in milliseconds
     * @param persistent true if this should be a persistent handle
     * @param createGuid the create GUID to use
     */
    public DurableHandleV2Request(long timeoutMs, boolean persistent, HandleGuid createGuid) {
        this.timeoutMs = timeoutMs;

        request.encode(buffer, 0);

        // Verify zero GUID
        byte[] extractedGuid = new byte[16];
        System.arraycopy(buffer, 4, extractedGuid, 0, 16);
        assertArrayEquals(zeroGuid, extractedGuid);
    }

    @Test
    @DisplayName("Test encode with all 0xFF GUID")
    void testEncodeWithMaxGuid() {
        byte[] maxGuid = new byte[16];