for (int i = 0; i < numThreads; i++) {
                    final int threadId = i;
                    executor.submit(() -> {
                        try {
                            startLatch.await(); // Wait for all threads to be ready
                            for (int j = 0; j < searchersPerThread; j++) {
                                processor.register(new TestSearcher(10 + threadId * 10 + j));

            break;
        }
        return OptionalEntity.empty();
    }

    /**
     * Gets a duplicate host entity from the form, setting audit fields.
     *
     * @param form the form containing duplicate host data
     * @return optional duplicate host entity with audit fields set
     */
    public static OptionalEntity<DuplicateHost> getDuplicateHost(final CreateForm form) {

        for (int i = 0; i < readerThreadCount; i++) {
            final int threadIndex = i;
            readerThreads[i] = new Thread(() -> {
                try {
                    startLatch.await(); // Wait for start signal
                    long endTime = System.currentTimeMillis() + testDurationMs;
                    while (System.currentTimeMillis() < endTime) {

                logger.error("Failed to update suggest index.", t);
                exitCode.set(1);
                latch.countDown();
            });

            try {
                latch.await();
            } catch (final InterruptedException ignore) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", ignore);
                }
                exitCode.set(1);

        };

        InputStreamThread thread = new InputStreamThread(is, StandardCharsets.UTF_8, 100, callback);
        thread.start();

        assertTrue("Should process all lines within timeout", latch.await(3, TimeUnit.SECONDS));

        thread.join(1000);

        assertEquals("All lines should be processed", 5000, receivedLines.size());
        assertEquals("First line", "Line number 0", receivedLines.get(0));

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            futures.add(executor.submit(() -> {
                try {
                    startLatch.await();
                    for (int i = 0; i < iterationsPerThread; i++) {
                        final Map<String, Object> params = new HashMap<>();
                        params.put("x", threadId * 1000 + i);

    public void test_isLogFilename_withLogExtension() {
        assertTrue(AdminLogAction.isLogFilename("fess.log"));
        assertTrue(AdminLogAction.isLogFilename("crawler.log"));
        assertTrue(AdminLogAction.isLogFilename("audit.log"));
        assertTrue(AdminLogAction.isLogFilename("application-2024-01-01.log"));
    }

    @Test
    public void test_isLogFilename_withLogGzExtension() {

                localLogMsg.get());
    }

    // ===== Access Denied Audit Log Tests =====

    @Test
    public void test_accessDenied() {
        activityHelper.useEcsFormat = false;
        activityHelper.accessDenied(OptionalThing.empty(), "/admin/user/");

                logger.debug("Failed to get scheduled job from thread local", e);
            }
        }
        return null;
    }

    /**
     * Logs script execution to the audit log.
     *
     * @param script the script content that was executed
     * @param result the execution result (e.g., "success" or "failure:ExceptionType")
     */

                } finally {
                    latch.countDown();
                }
            }, "ProcessCloser-output-" + sessionId).start();

            try {
                latch.await(streamCloseTimeout, TimeUnit.SECONDS);
            } catch (final InterruptedException e) {
                logger.warn("Interrupted to wait a process.", e);
            }
            try {