}

  /**
   * 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()
    }
  }

            }
            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);
            }

    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;

            }

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

            // Verify all results are consistent

        if (executorService != null) {
            try {
                executorService.shutdown();
                executorService.awaitTermination(60, TimeUnit.SECONDS);
            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            } finally {
                executorService.shutdownNow();
            }

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

        try {
            suggestJob.executeSuggestCreator();
            // In test environment, exception handling may vary
        } catch (JobProcessingException e) {

            // Expected exception
            assertTrue(e.getMessage().contains("filter.null"));
        }
    }

    // Test concurrent access
    public void test_get_concurrentAccess() throws InterruptedException {
        // Create multiple threads accessing the same property
        final String testKey = "domain.title";
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];

                exitCode.set(1);
                latch.countDown();
            });

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

                if (!task.isExecuted()) {
                    task.run();
                }
            }
        } catch (final InterruptedException e) {
            logger.warn("Interrupted to generate a thumbnail of {}: {}", thumbnailId, cmdList, e);
            Thread.currentThread().interrupt();
        } catch (final Exception e) {

        assertNotNull(emptyProvider);
    }

    // Test thread safety of provider creation
    public void test_threadSafetyProviderCreation() throws InterruptedException {
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final FessTimeResourceProvider[] providers = new FessTimeResourceProvider[threadCount];