*/
        public boolean isRunning() {
            return running;
        }

        /**
         * Waits for the crawling thread to terminate.
         * This method blocks until the thread completes its execution.
         * Interrupted exceptions are caught and logged at debug level.
         */
        public void awaitTermination() {
            try {
                join();

    }

    protected static void waitJob(final String namePrefix) {
        Boolean isRunning = false;
        int count = 0;
        long sleepTime = 50; // Start with 50ms

        // Wait until the crawler starts (with exponential backoff)
        while (count < 1500 && !isRunning) {
            ThreadUtil.sleep(sleepTime);
            count++;

    fun allVersionsAreIncludedInCrossVersionTests() {
        assertEquals("0.0", ALL_CROSS_VERSION_BUCKETS[0][0])
        assertEquals("99.0", ALL_CROSS_VERSION_BUCKETS[ALL_CROSS_VERSION_BUCKETS.size - 1][1])

        (1 until ALL_CROSS_VERSION_BUCKETS.size).forEach {
            assertEquals(ALL_CROSS_VERSION_BUCKETS[it - 1][1], ALL_CROSS_VERSION_BUCKETS[it][0])
        }
    }

        });
        thread.start();

        start = System.currentTimeMillis();
        helper.checkCrawlerStatus();
        end = System.currentTimeMillis();
        assertTrue(end - start >= 100); // Should wait until crawler is running
        thread.join();
    }

    @Test
    public void test_delayByRules() throws ParseException {
        IntervalControlHelper helper = createHelper("12:15", 1);

     *
     * @param sessionId the session ID to update
     * @param name the name to set for the crawling session (uses system name if blank)
     * @param dayForCleanup number of days until cleanup (sets expiration if >= 0)
     * @throws FessSystemException if unable to store the updated crawling session
     */
    public void updateParams(final String sessionId, final String name, final int dayForCleanup) {

    protected List<IntervalRule> ruleList = new ArrayList<>();

    /**
     * Checks the crawler status and waits if the crawler is not running.
     * This method blocks until the crawler is running again.
     */
    public void checkCrawlerStatus() {
        while (!crawlerRunning) {
            ThreadUtil.sleepQuietly(crawlerWaitMillis);
        }
    }

    /**

        { list: List<TestProjectDuration> -> MultipleTestProjectBucket(list) },
        numberOfBuckets,
        MAX_TEST_PROJECTS_PER_BUCKET,
        { numEmptyBuckets -> (0 until numEmptyBuckets).map { EmptyTestProjectBucket(it) }.toList() },
        { tests1, tests2 -> tests1 != tests2 },
    )
}

fun determineScenarioTestDurations(
    os: Os,

 * <li>Sends processed documents to the search engine for indexing</li>
 * <li>Manages cleanup of processed crawler session data</li>
 * </ul>
 *
 * <p>The updater runs continuously until crawling is finished and all documents are processed.
 * It includes error handling, retry logic, and performance monitoring capabilities.
 *
 */
public class IndexUpdater extends Thread {
    /** Logger for this class */

straightforward.  For core plugins in gradle/gradle, it's easy for an object to be created without applying its associated plugin. For instance, Spring has a plugin that uses the Checkstyle task directly without applying the Checkstyle plugin.

Until we can provide the same guarantees for core plugins, we need to be more conservative for existing classes and not follow best practices. This means conventions need to be set in both a plugin and the constructor. This keeps existing builds working,...