* in-flight request from any thread. It's the caller's responsibility to close the request body
   * and response body streams; otherwise resources may be leaked.
   *
   * This method is safe to be called concurrently, but provides limited guarantees. If a transport
   * layer connection has been established (such as a HTTP/2 stream) that is terminated. Otherwise

        // Clean up leases older than 5ms
        int cleaned = leaseManager.cleanupExpiredLeases(5);

        // At least the first lease should be cleaned
        assertTrue(cleaned >= 1);

        // Check if old lease was removed
        LeaseEntry entry1 = leaseManager.getLease(key1);
        if (cleaned == 2) {
            assertNull(entry1);

    }

    /**
     * Get all active leases
     *
     * @return map of lease keys to lease entries
     */
    public Map<Smb2LeaseKey, LeaseEntry> getAllLeases() {
        return new ConcurrentHashMap<>(leases);
    }

    /**
     * Clean up expired leases
     *
     * @param maxAgeMillis maximum age in milliseconds
     * @return number of leases cleaned up
     */

}
```

## 12. Future Enhancements

1. **Directory Leases**: Extend lease support for directories
2. **Lease Key Persistence**: Save lease keys for reconnection
3. **Parent-Child Relationships**: Implement hierarchical leases
4. **Lease Sharing**: Support lease sharing across handles

     * type.
     *
     * In practice, we are very unlikely to see `null`: The `WeakReference` to the enum constant
     * won't be cleared as long as the enum constant is referenced somewhere, and the enum constant
     * is referenced somewhere for as long as the enum class is loaded. *Maybe in theory* the enum
     * class could be unloaded after the above call to `getEnumConstants` but before we call

            // Then
            // Provider should still use FessUserTimeZoneProcessProvider.centralTimeZone
            // which was set when the class was loaded
            TimeZone providedTimeZone = provider.provide();
            assertNotNull(providedTimeZone);
            // The provider uses the static centralTimeZone which captures the original default

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

        // Step 9: Test lease break
        // Re-populate cache
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);
        assertTrue(cacheEntry.isComplete());

        // Simulate lease break with loss of read cache
        directoryLeaseManager.handleDirectoryLeaseBreak(leaseKey, Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING);

          if (exceptionClass.equals(knownGood.get())) {
            return;
          }
          // TODO(cpovirk): if reference has been cleared, remove it?
        }
        checkExceptionClassValidity(exceptionClass);

        /*
         * It's very unlikely that any loaded Futures class will see getChecked called with more
         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.

                        cleaned++;
                    } catch (Exception e) {
                        log.error("Failed to auto-close resource: {}", holder.resourceId, e);
                    }
                }
            }
        }

        if (cleaned > 0) {
            log.info("Cleaned up {} abandoned resources", cleaned);
        }
    }

    /**

yet present, thus enforcing authentication / re-authentication. This means an image pull might be attempted even in cases where a pod requests the `IfNotPresent` image pull policy, and might lead to the pod not starting if its pull policy is `Never` and is unable to present authentication information that lead to a previous successful pull of the image it is requesting. ([#128152](https://github.com/kubernetes/kubernetes/pull/128152), [@stlaz](https://github.com/stlaz)) [SIG API Machinery, Architecture,...