for (Thread thread : threads) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    fail("Thread interrupted");
                }
            }

            // Verify all results are consistent
            for (String result : results) {
                assertEquals("thread-test", result);

                    Thread.sleep(Long.MAX_VALUE);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new CIFSException("Watch interrupted");
                }
                return Collections.emptyList();
            }

            @Override

  }

  /**
   * Like [Object.wait], but throws an [InterruptedIOException] when interrupted instead of the more
   * awkward [InterruptedException].
   */
  @Throws(InterruptedIOException::class)
  internal fun waitForIo() {
    try {
      wait()
    } catch (_: InterruptedException) {
      Thread.currentThread().interrupt() // Retain interrupted status.
      throw InterruptedIOException()
    }
  }

  /**

        cleanupScheduler.shutdownNow();
        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("Interrupted while shutting down cleanup scheduler", e);
        }

        log.info("Authentication rate limiter closed");
    }

    /**
     * Per-account attempt tracking
     */

        }
    }

    // Test executeSuggestCreator with interrupted exception
    public void test_executeSuggestCreator_withInterruptedException() {
        createRequiredDirectories();
        mockProcessHelper.setThrowException(new InterruptedException("Interrupted"));

        try {
            suggestJob.executeSuggestCreator();

import org.jspecify.annotations.Nullable;

/**
 * A TimeLimiter that runs method calls in the background using an {@link ExecutorService}. If the
 * time limit expires for a given method call, the thread running the call will be interrupted.
 *
 * @author Kevin Bourrillion
 * @author Jens Nyman
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
// TODO: b/227335009 - Maybe change interruption behavior, but it requires thought.

   * If the timeout expires, not only will the output future finish, but also the input future
   * ({@code this}) will be cancelled and interrupted.
   *
   * @param timeout when to time out the future
   * @param scheduledExecutor The executor service to enforce the timeout.
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */
  @J2ktIncompatible

        // Wait for all threads to complete
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                fail("Thread interrupted");
            }
        }

        // Verify all stores were counted
        assertEquals(1000L, callback.getDocumentSize());

        // Test commit after concurrent operations

 *
 * <p>Future that delegates to another but will finish early (via a {@link TimeoutException} wrapped
 * in an {@link ExecutionException}) if the specified duration expires. The delegate future is
 * interrupted and cancelled if it times out.
 */
@J2ktIncompatible
@GwtIncompatible
final class TimeoutFuture<V extends @Nullable Object> extends FluentFuture.TrustedFuture<V> {

            });

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

        if (ComponentUtil.getFessConfig().isSuggestSearchLog()) {