mockConfig = mock(Configuration.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getLeaseTimeout()).thenReturn(30000);
        when(mockConfig.getMaxLeases()).thenReturn(1000);
        when(mockConfig.getLeaseBreakTimeout()).thenReturn(60);
        leaseManager = new LeaseManager(mockContext);
    }

    @AfterEach
    void tearDown() {
        if (leaseManager != null) {

            w.write(payload, payload.length, out);

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread
        assertThrows(SmbException.class, w::checkException);

	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
	n := 100
	if testing.Short() {
		n = 5
	}
	hammerRWMutex(t, 1, 1, n)
	hammerRWMutex(t, 1, 3, n)
	hammerRWMutex(t, 1, 10, n)
	hammerRWMutex(t, 4, 1, n)
	hammerRWMutex(t, 4, 3, n)
	hammerRWMutex(t, 4, 10, n)
	hammerRWMutex(t, 10, 1, n)
	hammerRWMutex(t, 10, 3, n)
	hammerRWMutex(t, 10, 10, n)
	hammerRWMutex(t, 10, 5, n)
}

						<div class="clearfix">
							<div class="mx-auto col-10 col-sm-8 col-md-8 col-lg-6">
								<la:text styleClass="query form-control"
									property="q" size="50" maxlength="1000" styleId="contentQuery"
									autocomplete="off" />
							</div>
						</div>
						<c:if test="${!empty popularWords}">
							<div class="clearfix">
								<p class="text-truncate">

 * Class-level state (static fields, metaclass mutations) persists across evaluations
 * of the same script. In Fess, scripts are short expressions configured by
 * administrators (e.g., "data1 > 10", "10 * boost1 + boost2") and do not use
 * static state, so this is acceptable.</p>
 *
 * <p>Resource Management: Each cached entry's GroovyClassLoader is closed on

        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

    private static class FastMockIndexUpdateCallback implements IndexUpdateCallback {
        @Override
        public long getExecuteTime() {
            return 100L;
        }

        @Override
        public long getDocumentSize() {

      if (deltaSeconds == Long.MIN_VALUE) {
        expiresAt = Long.MIN_VALUE
      } else if (deltaSeconds != -1L) {
        val deltaMilliseconds =
          if (deltaSeconds <= Long.MAX_VALUE / 1000) {
            deltaSeconds * 1000
          } else {
            Long.MAX_VALUE
          }
        expiresAt = currentTimeMillis + deltaMilliseconds
        if (expiresAt < currentTimeMillis || expiresAt > MAX_DATE) {

        assertNotNull(json);
        assertTrue(json.contains("\"type\":\"heartbeat\""));
        assertTrue(json.contains("\"instanceId\":\"test-instance\""));
        assertTrue(json.contains("\"createdTime\":1000"));
    }

    @Test
    public void test_toJson_emptyMap() {
        final String json = coordinatorHelper.toJson(Map.of());
        assertEquals("{}", json);
    }

    @Test

          () -> {
            currentFuture.get().addListener(listener, executor);
            return null;
          });
    }
    assertEquals(allTasks.size() + 1, barrier.getParties());
    for (int i = 0; i < 1000; i++) {
      Collections.shuffle(allTasks);
      AbstractFuture<String> future = new AbstractFuture<String>() {};
      currentFuture.set(future);
      for (Callable<?> task : allTasks) {

        }
        if (form.lang != null) {
            final Set<String> langSet = new HashSet<>();
            for (final String lang : form.lang) {
                if (StringUtil.isNotBlank(lang) && lang.length() < 1000) {
                    if (Constants.ALL_LANGUAGES.equals(lang)) {
                        langSet.clear();
                        break;
                    }