assertEquals(5, aggressivePolicy.getMaxAttempts());
        assertEquals(500, aggressivePolicy.getInitialDelayMs());
        assertEquals(60000, aggressivePolicy.getMaxDelayMs());
        assertEquals(1.5, aggressivePolicy.getBackoffMultiplier());
        assertTrue(aggressivePolicy.isExponentialBackoff());

        // CONSERVATIVE policy

## Configuration Properties

```properties
# Lease configuration
jcifs.smb.client.useLeases=true
jcifs.smb.client.leaseTimeout=30000

# Persistent handles
jcifs.smb.client.usePersistentHandles=true
jcifs.smb.client.durableTimeout=120000

# Multi-channel
jcifs.smb.client.useMultiChannel=true
jcifs.smb.client.maxChannels=4
jcifs.smb.client.channelBindingPolicy=required

            assertTrue(s1.isEmpty());
            // isBlank will fail if sub_authority is null, so we skip that check for s1

            // All-zero subauthorities
            byte[] ident = new byte[] { 0, 0, 0, 0, 0, 0 };
            rpc.sid_t st = buildSidT((byte) 1, ident, 0, 0);
            SID s2 = new SID(st, jcifs.SID.SID_TYPE_USE_NONE, null, null, false);
            assertFalse(s2.isEmpty());

        byte[] buffer = new byte[22];
        int idFileSystem = 0;
        int sectPerAlloc = 1000;
        int alloc = 1000000; // Large allocation count
        int free = 500000;
        int bytesPerSect = 4096;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);
        offset += 4;

        // Verify O(1) performance - should be reasonably fast (allowing for JVM overhead)
        assertTrue(avgAllocTimeNs < 10000, "Average allocation should be under 10000ns (O(1) performance)");
        assertTrue(avgReleaseTimeNs < 10000, "Average release should be under 10000ns (O(1) performance)");
        assertEquals(threadCount * operationsPerThread, allocations.get());

        buffer.put(new byte[] { 0, 0, 0, 0, 0, 1 }); // IdentifierAuthority
        buffer.putInt(0); // SubAuthority

        // Group SID at offset 40
        buffer.position(40);
        buffer.put((byte) 0x01); // Revision
        buffer.put((byte) 0x01); // SubAuthorityCount
        buffer.put(new byte[] { 0, 0, 0, 0, 0, 2 }); // IdentifierAuthority
        buffer.putInt(0); // SubAuthority

    private final ReadWriteLock lock;
    private final CIFSContext context;
    private final ScheduledExecutorService cleanupExecutor;
    private static final long DEFAULT_LEASE_CLEANUP_INTERVAL = 60000; // 60 seconds
    private static final int DEFAULT_LEASE_BREAK_TIMEOUT = 60; // 60 seconds per MS-SMB2

    /**
     * Create a new lease manager
     *
     * @param context CIFS context
     */

        /**
         * Default constructor for TimeOfDayInfo.
         */
        public TimeOfDayInfo() {
        }

        /**
         * The time elapsed since 00:00:00, January 1, 1970 GMT.
         */
        public int elapsedt;
        /**
         * The number of milliseconds from the start of the current second.
         */
        public int msecs;
        /**

        }
    }

    private void performHealthCheck() {
        for (ChannelInfo channel : channels.values()) {
            if (channel.getIdleTime() > 60000) { // 1 minute idle
                // Send keep-alive
                try {
                    sendKeepAlive(channel);
                } catch (Exception e) {

    // Rate limiting
    private final Map<String, AtomicLong> rateLimitCounters = new ConcurrentHashMap<>();
    private volatile long rateLimitWindow = 60000; // 1 minute
    private volatile int maxEventsPerWindow = 10000; // Increased for tests

    /**
     * Security event types
     */
    public enum EventType {