it.close();

        // Assert
        assertFalse(it.hasNext());
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("doCloseInternal throwing still releases exactly once and next() recovers")
    void closeInternalThrowsButReleases() throws Exception {
        // Arrange
        stubAcquireReturnsSelf();
        FileEntry initial = entry("first");

        // The normalization removes all duplicate backslashes, so \\\\server becomes \server
        // This test validates that paths which should be UNC but aren't detected due to normalization
        // still pass validation (which is the current behavior, though not ideal)

        // These paths normalize to \server\share which is NOT detected as UNC due to normalization

        // Verify we get a copy, not the original
        rawKey[0] = (byte) ~rawKey[0];
        byte[] rawKey2 = keyManager.getRawKey(sessionId);
        assertArrayEquals(testKey, rawKey2, "Should still match original");
    }

    @Test
    public void testRemoveSessionKey() {
        String sessionId = "test-session-3";
        keyManager.storeSessionKey(sessionId, testKey, "AES");

            // Verify FILE_NOTIFY_CHANGE_SIZE is removed
            assertFalse((flags & FileNotifyInformation.FILE_NOTIFY_CHANGE_SIZE) != 0);

            // Verify other flags are still present
            assertTrue((flags & FileNotifyInformation.FILE_NOTIFY_CHANGE_FILE_NAME) != 0);
            assertTrue((flags & FileNotifyInformation.FILE_NOTIFY_CHANGE_LAST_WRITE) != 0);
        }

        @Test

        buffer[2] = (byte) byte2;
        buffer[3] = (byte) byte3;

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then - should still read 4 bytes regardless of reserved field value
        assertEquals(4, bytesRead);
    }

    @Test
    @DisplayName("Should handle edge case structure sizes")
    void testEdgeCaseStructureSizes() {

        directoryLeaseManager.handleDirectoryLeaseBreak(key2, Smb2LeaseState.SMB2_LEASE_NONE);

        // Only second directory should be invalidated
        assertFalse(entry2.isComplete());
        // First directory should still be cached (though modified by previous change)
        assertNotNull(directoryLeaseManager.getCacheEntry(dir1));
    }

    @Test
    public void testCacheExpiration() throws Exception {

                    // Use adaptive polling interval based on activity
                    long pollInterval = determinePollInterval(handle);
                    Thread.sleep(pollInterval);

                    // Check if still active
                    if (!handle.isActive()) {
                        break;
                    }

                    // In a real implementation, we would process actual change notifications here

    // ... trigger server failover ...
    
    // Verify that witness notification was received and handled
    assertTrue(listener.waitForNotification(30000));  // 30 second timeout
    
    // Verify file is still accessible after failover
    assertTrue(file.exists());
}

@Test
public void testWitnessServiceDiscovery() throws Exception {
    CIFSContext context = getTestContext();

        docMap.put("_id", "docid1");

        // Fill the queue
        thumbnailManager.offer(docMap);

        // Try to add another - should succeed (warning logged but still returns true)
        Map<String, Object> docMap2 = new HashMap<>();
        docMap2.put("_id", "docid2");
        generator.task = new Tuple3<>("generator1", "docid2", "path2");

 * @param <V> Value parameter type
 */
final class DirectedGraphConnections<N, V> implements GraphConnections<N, V> {
  /**
   * A wrapper class to indicate a node is both a predecessor and successor while still providing
   * the successor value.
   */
  private static final class PredAndSucc {
    private final Object successorValue;

    PredAndSucc(Object successorValue) {
      this.successorValue = successorValue;