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

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

    // (Still done).
    assertThat(secondResponseCode.get()).isEqualTo(200)
  }

  private fun buildRequestThread(
    path: String,
    responseCode: AtomicInteger,
  ): Thread =
    Thread {
      val url = mockWebServer.url(path).toUrl()
      val conn: HttpURLConnection
      try {
        conn = url.openConnection() as HttpURLConnection

    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyThreadWasNotInterrupted() {
    assertFalse(Thread.currentThread().isInterrupted());
  }

  static void clearInterrupt() {
    Thread.interrupted();
  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.

                    watchCount++;
                    try {
                        // Simulate some processing time
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return Arrays.asList(createMockNotification("file" + watchCount + ".txt"));
                }

                    Thread.sleep(pollInterval);

                } catch (InterruptedException e) {
                    log.debug("Async notification monitoring interrupted for {}", registrationId);
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {

 * methods that they depend on are thread-safe.
 *
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingSet<E extends @Nullable Object> extends ForwardingCollection<E>
    implements Set<E> {
  // TODO(lowasser): identify places where thread safety is actually lost

@J2ktIncompatible
@GwtIncompatible
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();

            Smb2LeaseKey key1 = limitedManager.requestLease("/share/file1.txt", Smb2LeaseState.SMB2_LEASE_READ_CACHING);
            Thread.sleep(5); // Small delay to ensure different timestamps
            Smb2LeaseKey key2 = limitedManager.requestLease("/share/file2.txt", Smb2LeaseState.SMB2_LEASE_READ_CACHING);
            Thread.sleep(5); // Small delay to ensure different timestamps

 * This class serves as a foundation for concrete CIFS context implementations.
 *
 * @author mbechler
 */
public abstract class AbstractCIFSContext extends Thread implements CIFSContext {

    private static final Logger log = LoggerFactory.getLogger(AbstractCIFSContext.class);
    private boolean closed;

    /**