new IOException("Failed to reconnect after " + maxRetries + " attempts"));
        }
        
        return CompletableFuture.supplyAsync(() -> {
            try {
                // Wait before retry (except first attempt)
                if (attempt > 0) {
                    Thread.sleep(retryDelay * attempt);
                }
                
                // Create reconnect context

                                     readRegion.getSize());
            
            // Send request header via RDMA send
            sendWithRdmaSendReceive(request);
            
            // Wait for server to write data directly to our buffer via RDMA
            // No additional receive needed - data written directly to memory
            
            // Create response with data from RDMA buffer

        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

        assertTrue(entry.isComplete());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        Thread.sleep(100);

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());

        // After expiration, cache should be treated as invalid by manager

        int requestedState = Smb2LeaseState.SMB2_LEASE_READ_CACHING;

        Smb2LeaseKey key = leaseManager.requestLease(path, requestedState);
        assertNotNull(leaseManager.getLease(key));

        // Wait a bit and then cleanup with a very short expiration time
        Thread.sleep(10);
        int cleaned = leaseManager.cleanupExpiredLeases(1); // 1ms expiration

        assertEquals(1, cleaned);

        // Create an expired handle
        HandleInfo expiredHandle = new HandleInfo("/test/file.txt", new HandleGuid(), new byte[16], HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        Thread.sleep(150);

        CompletableFuture<HandleInfo> future = reconnector.reconnectHandle(expiredHandle, new IOException("Network error"));

                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS));
        executor.shutdown();
    }

    @Test
    @DisplayName("Test invalid session ID handling")
    public void testInvalidSessionIdHandling() {

            return "Free up disk space or use a different location";
        case QUOTA:
            return "Contact administrator to increase quota limits";
        case LOCK:
            return "Release existing locks or wait for them to be released";
        case BUFFER:
            return "Reduce buffer usage or increase buffer pool size";
        case THREAD_POOL:
            return "Reduce concurrent operations or increase thread pool size";

    /**
     * Function code to peek at named pipe data without removing it
     */
    public static final int FSCTL_PIPE_PEEK = 0x0011400C;
    /**
     * Function code to wait for a named pipe to become available
     */
    public static final int FSCTL_PIPE_WAIT = 0x00110018;
    /**
     * Function code to transceive data on a named pipe
     */

            final int threadId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        startLatch.await();
                        for (int j = 0; j < operationsPerThread; j++) {
                            // Transform operation
                            ResponseData responseData = new ResponseData();

                    }
                }
            });
        }

        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join();
        }

        // Verify results
        assertTrue(exceptions.isEmpty());