null);

        assertFalse(durableInfo.isExpired());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        assertTrue(durableInfo.isExpired());

        // Test persistent handle (never expires)

    @RepeatedTest(10)
    @DisplayName("Test thread safety")
    void testThreadSafety() throws InterruptedException {
        SimpleCircuitBreaker breaker = new SimpleCircuitBreaker("concurrent", 5, 3, 100);
        AtomicInteger successCount = new AtomicInteger(0);
        AtomicInteger failureCount = new AtomicInteger(0);

        // Create multiple threads
        Thread[] threads = new Thread[10];

    private final AtomicInteger registrationCounter = new AtomicInteger(0);
    private final ConcurrentHashMap<String, MockRegistration> registrations = new ConcurrentHashMap<>();
    private Thread serverThread;

    /**
     * Mock registration data
     */
    private static class MockRegistration {
        final String registrationId;
        final String shareName;
        final String serverAddress;

    // Enqueueing the red task starts a thread because the head of the queue changed.
    redQueue.execute("red task") {
      log += "red:starting@${taskFaker.nanoTime}"
      taskFaker.sleep(100.µs)
      log += "red:finishing@${taskFaker.nanoTime}"
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    // Enqueueing the blue task doesn't start a thread because the red one is still starting.

    return Synchronized.biMap(bimap, null);
  }

  /**
   * Returns an unmodifiable view of the specified bimap. This method allows modules to provide
   * users with "read-only" access to internal bimaps. Query operations on the returned bimap "read
   * through" to the specified bimap, and attempts to modify the returned map, whether direct or via
   * its collection views, result in an {@code UnsupportedOperationException}.
   *

    return Synchronized.biMap(bimap, null);
  }

  /**
   * Returns an unmodifiable view of the specified bimap. This method allows modules to provide
   * users with "read-only" access to internal bimaps. Query operations on the returned bimap "read
   * through" to the specified bimap, and attempts to modify the returned map, whether direct or via
   * its collection views, result in an {@code UnsupportedOperationException}.
   *

 * example involving two locks and two threads, deadlock occurs when one thread acquires Lock A, and
 * then Lock B, while another thread acquires Lock B, and then Lock A:
 *
 * <pre>
 * Thread1: acquire(LockA) --X acquire(LockB)
 * Thread2: acquire(LockB) --X acquire(LockA)
 * </pre>
 *
 * <p>Neither thread will progress because each is waiting for the other. In more complex

    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    /**
     * Thread priority for index updater operations.
     */
    protected int indexUpdaterPriority = Thread.MAX_PRIORITY;

    /**
     * Thread priority for crawler operations.
     */
    protected int crawlerPriority = Thread.NORM_PRIORITY;

    /**
     * Synchronized list of active crawlers.
     */

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

                threads[i].start();
            }

            // Wait for all threads to complete
            for (Thread thread : threads) {
                thread.join();
            }
        }

        // Then
        for (int i = 0; i < threadCount; i++) {
            assertTrue(results[i], "Thread " + i + " should have completed successfully");
        }
    }

    @Test