assertEquals("adaptive", config.getLoadBalancingStrategy(), "Default strategy should be adaptive");
        assertEquals(10, config.getChannelHealthCheckInterval(), "Default health check interval should be 10");
    }

    @Test
    void testMultiChannelEnabledProperty() throws CIFSException {
        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useMultiChannel", "false");

                    } else {
                        final long interval = fessConfig.getThumbnailGeneratorIntervalAsInteger().longValue();
                        if (interval > 0) {
                            ThreadUtil.sleep(interval);
                        }
                    }
                } else {

 * <li>{@link #indexFromQueryLog(QueryLog[])} - Index from multiple query logs.
 * <li>{@link #indexFromQueryLog(QueryLogReader, int, long)} - Index from query log reader with specified document per request and request interval.
 * <li>{@link #indexFromDocument(Map[])} - Index from an array of documents.
 * <li>{@link #indexFromSearchWord(String, String[], String[], String[], int, String[])} - Index from search word.

     */
    public static DataStoreFactory getDataStoreFactory() {
        return getComponent(DATA_STORE_FACTORY);
    }

    /**
     * Gets the interval control helper component.
     * @return The interval control helper.
     */
    public static IntervalControlHelper getIntervalControlHelper() {
        return getComponent(INTERVAL_CONTROL_HELPER);
    }

    /**

     * @param maxAttemptsPerIp max attempts from single IP
     * @param maxGlobalAttemptsPerMinute max global attempts per minute
     * @param lockoutDuration duration to lock out account/IP
     * @param cleanupInterval interval for cleaning up old entries
     */
    public AuthenticationRateLimiter(int maxAttemptsPerAccount, int maxAttemptsPerIp, int maxGlobalAttemptsPerMinute,
            Duration lockoutDuration, Duration cleanupInterval) {

                            processAsyncNotificationMessage(registration, message);
                        }
                    }

                    // Normal polling interval: max 5 seconds, increased based on failures
                    long pollInterval = Math.min(MAX_POLL_INTERVAL, BASE_POLL_INTERVAL + (registration.getHeartbeatFailures() * 500));
                    Thread.sleep(pollInterval);

     *
     * @return load balancing strategy
     */
    String getLoadBalancingStrategy();

    /**
     * Channel health check interval in seconds
     *
     * Property {@code jcifs.smb.client.channelHealthCheckInterval} (int, default 10)
     *
     * @return health check interval in seconds
     */
    int getChannelHealthCheckInterval();

    /**
     * Property {@code jcifs.smb.client.handleStateDirectory}

     */
    @Test
    public void testRetryLogicMaxRetryCount() throws Exception {
        fesenClient.setMaxRetryCount(5);
        fesenClient.setRetryInterval(10L); // Short interval for testing

        final AtomicInteger attemptCount = new AtomicInteger(0);
        final ActionFuture<String> mockFuture = mock(ActionFuture.class);

        // Fail 5 times, succeed on 6th attempt

     */
    public String getProductVersion() {
        return productVersion;
    }

    /**
     * Sets the interval for checking the system CPU load.
     *
     * @param systemCpuCheckInterval The interval in milliseconds.
     */
    public void setSystemCpuCheckInterval(final long systemCpuCheckInterval) {
        this.systemCpuCheckInterval = systemCpuCheckInterval;

        public int hunds;
        /**
         * The time zone offset from UTC in minutes.
         */
        public int timezone;
        /**
         * The time interval for each tick of the clock in 0.0001 seconds.
         */
        public int tinterval;
        /**
         * The current day of the month (1-31).
         */
        public int day;
        /**
         * The current month (1-12).
         */