* Represents a rule for controlling crawler intervals.
     * Each rule defines a time range, applicable days, and delay amount.
     */
    public static class IntervalRule {
        /** Starting hour of the interval */
        protected int fromHours;

        /** Starting minute of the interval */
        protected int fromMinutes;

        /** Ending hour of the interval */
        protected int toHours;

        this.ruleManager = ruleManager;
    }

    /**
     * Returns the interval controller.
     * @return The IntervalController instance.
     */
    public IntervalController getIntervalController() {
        return intervalController;
    }

    /**
     * Sets the interval controller.
     * @param intervalController The IntervalController instance to set.
     */

 *
 */
public class HostIntervalControllerTest extends PlainTestCase {

    /**
     * Test that crawling intervals for the same host work correctly.
     */
    public void test_delayBeforeProcessing() {
        // Number of concurrent tasks
        final int numTasks = 100;
        // Interval in milliseconds
        final Long waittime = 100L;

        CrawlingParameterUtil.setUrlQueue(new UrlQueueImpl());

    }

    @Override
    public Collection<Object> values() {
        return getProperties().values();
    }

    /**
     * Sets the check interval for file modifications.
     *
     * @param checkInterval
     *            The new check interval in milliseconds.
     */
    public void setCheckInterval(final long checkInterval) {
        this.checkInterval = checkInterval;
    }

            return timestamp;
        }

        /**
         * Sets the notification timestamp.
         *
         * @param timestamp the timestamp value in FILETIME format (100-nanosecond intervals since January 1, 1601 UTC)
         */
        public void setTimestamp(long timestamp) {
            this.timestamp = timestamp;
        }

        /**

import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.Configuration;
import jcifs.SmbConstants;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2CloseResponse functionality
 */
@ExtendWith(MockitoExtension.class)
@DisplayName("Smb2CloseResponse Tests")
class Smb2CloseResponseTest {

     *
     * @param handle notification handle
     * @return polling interval in milliseconds
     */
    private long determinePollInterval(ChangeNotificationHandle handle) {
        int failures = getFailureCount(handle);

        // Base interval starts at 1 second, increases with failures
        // Max interval is 30 seconds for inactive directories

    /**
     * Set the health check interval
     * @param millis the health check interval in milliseconds
     */
    public void setHealthCheckInterval(int millis) {
        if (millis <= 0) {
            throw new IllegalArgumentException("Health check interval must be positive");
        }
        this.healthCheckInterval = millis;
        log.info("Set health check interval to {} ms", millis);
    }

    /**

            if (message.isSuccess()) {
                // Set recommended heartbeat interval from server
                response.setRecommendedHeartbeatInterval(message.getHeartbeatInterval());
                log.debug("Witness heartbeat successful, next interval: {} ms", message.getHeartbeatInterval());
            } else {
                response.setError(message.getErrorMessage());

        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).
         */