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

            throw e;
        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Command execution interrupted due to timeout for user: username={}", username, e);
                }
                throw new CommandExecutionException("The command execution is timeout for user: " + username, e);
            }

            }).start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            fail("Thread safety test interrupted");
        }

        // In test environment, some operations might not work due to missing request context
        // but the methods should not throw unexpected exceptions
    }

                if (!task.isExecuted()) {
                    task.run();
                }
            }
        } catch (final InterruptedException e) {
            logger.warn("Interrupted generating thumbnail: id={}, command={}", thumbnailId, cmdList, e);
            Thread.currentThread().interrupt();
        } catch (final Exception e) {

        }

        indexUpdater.setFinishCrawling(true);
        try {
            indexUpdater.join();
        } catch (final InterruptedException e) {
            logger.warn("Interrupted index update.", e);
        }

        crawlingInfoHelper.putToInfoMap(Constants.WEB_FS_INDEX_EXEC_TIME, Long.toString(indexUpdater.getExecuteTime()));

            try {
                latch.await();
            } catch (InterruptedException e) {
                result.addErrorArtifactException(
                        new ArtifactResolutionException("Resolution interrupted", rootArtifact, e));
            }
        }

        // We want to send the root artifact back in the result but we need to do this after the other dependencies
        // have been resolved.

                        }
                    }
                } catch (final InterruptedException e) {
                    if (generating && logger.isDebugEnabled()) {
                        logger.debug("Interrupted task.", e);
                    }
                } catch (final Exception e) {
                    if (generating) {
                        logger.warn("Failed to generate thumbnail.", e);
                    }

    assertThat(Thread.interrupted()).isFalse();
    SettableFuture<Integer> cancelledFuture = SettableFuture.create();
    cancelledFuture.cancel(true);
    assertThat(Thread.interrupted()).isFalse();
    ListenableFuture<Integer> future = submitAsync(() -> cancelledFuture, directExecutor());
    assertThat(future.isDone()).isTrue();
    assertThat(Thread.interrupted()).isFalse();
  }

    assertThat(Thread.interrupted()).isFalse();
    SettableFuture<Integer> cancelledFuture = SettableFuture.create();
    cancelledFuture.cancel(true);
    assertThat(Thread.interrupted()).isFalse();
    ListenableFuture<Integer> future = submitAsync(() -> cancelledFuture, directExecutor());
    assertThat(future.isDone()).isTrue();
    assertThat(Thread.interrupted()).isFalse();
  }

		// This is needed as the remote hosts are sometime
		// not available immediately.
		select {
		case <-globalOSSignalCh:
			return fmt.Errorf("The endpoint resolution got interrupted")
		default:
			for i, resolved := range resolvedList {
				if resolved {
					// Continue if host is already resolved.
					continue
				}

				if endpoints[i].Host == "" {