HandleInfo info = new HandleInfo("/test/file.txt", testGuid, new byte[16], HandleType.DURABLE_V2, 120000, null);

        assertArrayEquals(new byte[16], info.getFileId());

        info.updateFileId(testFileId);
        assertArrayEquals(testFileId, info.getFileId());

        // Test invalid file ID length
        assertThrows(IllegalArgumentException.class, () -> {
            info.updateFileId(new byte[8]);
        });

     */
    public HandleGuid getCreateGuid() {
        return createGuid;
    }

    /**
     * Get the file ID
     * @return copy of the 16-byte file ID
     */
    public byte[] getFileId() {
        return Arrays.copyOf(fileId, 16);
    }

    /**
     * Get the handle type
     * @return the handle type
     */
    public HandleType getType() {
        return type;
    }

        log.debug("Performing reconnection for handle: {} (type: {})", info.getPath(), info.getType());

        // Create reconnect context
        DurableHandleReconnect reconnectCtx = new DurableHandleReconnect(info.getFileId());

        // This would typically involve:
        // 1. Creating a new Smb2CreateRequest with reconnect context
        // 2. Adding lease context if needed

     * @return the file ID if available, null otherwise
     */
    public byte[] getExistingHandle(String path) {
        HandleInfo info = getHandleForReconnect(path);
        return info != null ? info.getFileId() : null;
    }

    /**
     * Store handle information after successful create
     * @param path the file path
     * @param fileId the 16-byte file ID
     * @param guid the handle GUID
     */

    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    /**
     * Get the file ID
     * @return the 16-byte file ID
     */
    public byte[] getFileId() {
        return Arrays.copyOf(fileId, 16);
    }

    @Override
    public int size() {
        // Context header (16) + name length (4) + padding to 8-byte alignment + data (16)

        }

        DurableHandleReconnect reconnect = new DurableHandleReconnect(fileId);

        assertEquals("DHnC", new String(reconnect.getName()));
        assertArrayEquals(fileId, reconnect.getFileId());
        assertTrue(reconnect.size() > 0);

        // Test encoding
        byte[] buffer = new byte[reconnect.size()];
        int encoded = reconnect.encode(buffer, 0);

                }

                try {
                    if (th.isSMB2()) {
                        final Smb2ReadRequest request = new Smb2ReadRequest(th.getConfig(), fd.getFileId(), b, off);
                        request.setOffset(type == SmbConstants.TYPE_NAMED_PIPE ? 0 : this.fp);
                        request.setReadLength(r);

            fileId[i] = (byte) (i + 1);
        }

        manager.updateHandleFileId(guid, fileId);

        HandleInfo info = manager.getHandleByGuid(guid);
        assertArrayEquals(fileId, info.getFileId());
    }

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

            if (th.isSMB2()) {
                final Smb2IoctlRequest req =
                        new Smb2IoctlRequest(th.getConfig(), Smb2IoctlRequest.FSCTL_PIPE_TRANSCEIVE, fh.getFileId(), inB);
                req.setFlags(Smb2IoctlRequest.SMB2_O_IOCTL_IS_FSCTL);
                req.setInputData(new ByteEncodable(buf, off, length));
                req.setMaxOutputResponse(maxRecvSize);

    public int getFid() throws SmbException {
        if (!isValid()) {
            throw new SmbException("Descriptor is no longer valid");
        }
        return this.fid;
    }

    public byte[] getFileId() throws SmbException {
        if (!isValid()) {
            throw new SmbException("Descriptor is no longer valid");
        }
        return this.fileId;
    }

    /**
     * @return the initialSize