public boolean isTerminated() {
    synchronized (lock) {
      return shutdown && runningTasks == 0;
    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {

                        observations[threadIndex].add(dataStore.alive);
                        Thread.yield(); // Allow other threads to run
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            readerThreads[i].start();
        }

        // Writer thread sets alive to false early

import org.dbflute.optional.OptionalThing;
import org.junit.jupiter.api.Test;

/**
 * Error handling tests for RankFusionProcessor.
 * Tests exception handling improvements including InterruptedException and ExecutionException.
 */
public class RankFusionProcessorErrorHandlingTest extends UnitFessTestCase {

    private static final String ID_FIELD = "_id";

    /**

    private volatile boolean running = false;

    @Override
    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    void waitForStart() throws InterruptedException {
      startLatch.await();
    }

    void stop() {
      stopLatch.countDown();
    }

  }

  @Benchmark
  long add(int reps) throws ExecutionException, InterruptedException {
    return doMultithreadedLoop(
        new Callable<Long>() {
          @Override
          public Long call() {
            return runAddSingleThread(reps);
          }
        });
  }

  @Benchmark
  long addRemove(int reps) throws ExecutionException, InterruptedException {
    return doMultithreadedLoop(
        new Callable<Long>() {

    try {
      getChecked(future, TwoArgConstructorException.class);
      fail();
    } catch (TwoArgConstructorException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(InterruptedException.class);
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {

    try {
      getChecked(future, TwoArgConstructorException.class);
      fail();
    } catch (TwoArgConstructorException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(InterruptedException.class);
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {

        // Guava Cache handles expiration automatically
        // Wait for cache to expire and call cleanup
        try {
            Thread.sleep(100L);
        } catch (final InterruptedException e) {
            // ignore
        }

        rateLimitHelper.cleanup();
        // After cleanup, the expired entry should be removed

        }
        responseQueue.put(new Response(request.methodName, result, null));
      }
    } catch (ThreadDeath death) {
      return;
    } catch (InterruptedException ignored) {
      // SynchronousQueue sometimes throws InterruptedException while the threads are stopping.
    } catch (Throwable uncaught) {
      this.uncaughtThrowable = uncaught;
    }
  }

  private static class Request {

                cal.set(Calendar.DAY_OF_WEEK, day);
                return cal;
            }
        };
    }

    @Test
    public void test_checkCrawlerStatus() throws InterruptedException {
        IntervalControlHelper helper = new IntervalControlHelper();
        helper.setCrawlerWaitMillis(50);

        // Test when crawler is running
        assertTrue(helper.isCrawlerRunning());