throw new SuggesterException("An error occurred during the deferred computation.", error);
                }
                return response;
            } catch (final InterruptedException e) {
                throw new InterruptedRuntimeException(e);
            }
        }
    }

            docMap.put("mimetype", mimeType);
            assertFalse("Should not support " + mimeType, thumbnailGenerator.isTarget(docMap));
        }
    }

    public void test_concurrentOperations() throws InterruptedException {
        // Test thread safety with concurrent operations
        final int threadCount = 10;
        Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

  @SuppressWarnings("InfiniteLoopStatement")
  @Override
  public void run() {
    while (true) {
      try {
        if (!cleanUp(queue.remove())) {
          break;
        }
      } catch (InterruptedException e) {
        // ignore
      }
    }
  }

  /**
   * Cleans up the given reference and any other references already in the queue. Catches and logs
   * all throwables.
   *

            }
            return exitValue;
        } catch (final CrawlerSystemException e) {
            throw e;
        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {
                throw new CommandExecutionException("The command execution is timeout: " + String.join(" ", commands), e);
            }

        failover.shutdown();

        // Should not throw any exceptions
        assertDoesNotThrow(() -> failover.shutdown());
    }

    @Test
    void testConcurrentFailureHandling() throws InterruptedException {
        IOException error = new IOException("Connection failed");

        // Simulate concurrent failures
        Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {

            // Expected in test environment without proper server setup
        }

        assertDoesNotThrow(() -> channelManager.shutdown());
    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {

          waitingCoordinatorTask = null
          waitingCoordinatorNotified = false
          if (waitingCoordinatorInterrupted) {
            waitingCoordinatorInterrupted = false
            throw InterruptedException()
          }
        }

        override fun <T> decorate(queue: BlockingQueue<T>) = TaskFakerBlockingQueue(queue)
      },
      logger = logger,
    )

    }
    /*
     * TODO(cpovirk): Clear interrupt status here? We currently don't, which means that an interrupt
     * before, during, or after runInterruptibly() (unless it produced an InterruptedException
     * caught above) can linger and affect listeners.
     */
  }

  /**
   * Called before runInterruptibly - if true, runInterruptibly and afterRanInterruptibly will not
   * be called.
   */

            while (crawler.crawlerContext.getStatus() != CrawlerStatus.RUNNING && System.currentTimeMillis() - startTime < 5000) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            assertEquals(CrawlerStatus.RUNNING, crawler.crawlerContext.getStatus());

    mapMaker.useCustomMap = true;
    testAddAndRemove(mapMaker.<String, AtomicInteger>makeMap());
  }

  private void testAddAndRemove(ConcurrentMap<String, AtomicInteger> map)
      throws ExecutionException, InterruptedException {

    ConcurrentHashMultiset<String> multiset = new ConcurrentHashMultiset<>(map);
    int nThreads = 20;
    int tasksPerThread = 10;
    int nTasks = nThreads * tasksPerThread;