entry.updateChild("file1.txt", 1024L, 1000L, false, 0x20, 500L, 800L);
        entry.markComplete();

        // Break lease with loss of read cache
        int newState = Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING; // Lost read cache
        directoryLeaseManager.handleDirectoryLeaseBreak(leaseKey, newState);

        // Cache should be invalidated
        assertFalse(entry.isComplete());

    /**
     * Closes a {@link Closeable}.
     * <p>
     * If an exception is thrown by {@link Closeable#close()}, an error message is logged. The exception is not rethrown. This prevents the original exception from being lost in situations like the following:
     * </p>
     * <pre>
     * InputStream is = ...;
     * try {
     *   is.read(...);
     * } finally {
     *   close(is);
     * }
     * </pre>
     * <p>

    
    public List<SmbFile> batchExists(List<String> paths) {
        // Group paths by parent directory
        Map<String, List<String>> pathsByParent = paths.stream()
            .collect(Collectors.groupingBy(this::getParentPath));
        
        List<SmbFile> results = new ArrayList<>();
        
        for (Map.Entry<String, List<String>> entry : pathsByParent.entrySet()) {

     *
     * @param directoryPath directory path
     * @return list of cached files or null
     */
    public List<SmbFile> getCachedDirectoryListing(String directoryPath) {
        DirectoryCacheEntry entry = getCacheEntry(directoryPath);
        if (entry == null || !entry.isComplete()) {
            return null;
        }

        List<SmbFile> files = new ArrayList<>();

        ChannelInfo channel = new ChannelInfo("failover-test", mockTransport, nic, nic);
        channel.setState(ChannelState.ESTABLISHED);

        // Simulate failure
        IOException failure = new IOException("Connection lost");
        failover.handleFailure(channel, failure);

        // Verify channel state changed
        assertFalse(channel.isHealthy());
        assertEquals(ChannelState.FAILED, channel.getState());
    }

        byte[] buffer = new byte[8];
        long time = System.currentTimeMillis();
        ServerMessageBlock.writeTime(time, buffer, 0);
        long readTime = ServerMessageBlock.readTime(buffer, 0);
        // Precision may be lost, so check within a second
        assertTrue(Math.abs(time - readTime) < 1000);
    }

    @Test
    void testTimeReadWriteZero() {
        byte[] buffer = new byte[8];

            }
        };
    }
}
```

### 10.2 Batch Handle Operations
```java
public class BatchHandleOperations {
    public void reconnectMultipleHandles(List<HandleInfo> handles) {
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        
        for (HandleInfo handle : handles) {
            futures.add(CompletableFuture.runAsync(() -> {
                try {

    void testErrorCategories() {
        // Network error
        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_RESET, "Connection lost");
        assertTrue(exception.isNetworkError());
        assertFalse(exception.isAuthenticationError());
        assertFalse(exception.isFileSystemError());
        assertFalse(exception.isTransientError());

        // Authentication error

```java
package jcifs.internal.witness;

import java.util.List;
import java.util.ArrayList;

public class WitnessNotification {
    private final WitnessEventType eventType;
    private final long timestamp;
    private final String resourceName;
    private final List<WitnessIPAddress> newIPAddresses;
    private final List<WitnessIPAddress> oldIPAddresses;
    private final String clientAccessPoint;

                            this.name));
                }
                if ((next == null || chain.allowChain(next)) && totalSize + size < maxSize && this.credits.tryAcquire(cost)) {
                    totalSize += size;
                    last = chain;
                    chain = next;
                } else if (last == null && totalSize + size > maxSize) {