assertTrue(user.refresh());
        assertEquals(1, user.getRefreshCount());

        // Test multiple refreshes
        user.refresh();
        user.refresh();
        assertEquals(3, user.getRefreshCount());

        // Test custom implementation that returns false
        user = new TestRefreshableFessUser("testuser", false);
        assertFalse(user.refresh());

        createWebConfig();
        logger.info("WebConfig is created");
        refresh();
        webConfigId = getWebConfigIds(NAME_PREFIX).get(0);

        createJob();
        logger.info("Job is created: {}", webConfigId);
        refresh();

        startJob(NAME_PREFIX);

        waitJob(NAME_PREFIX);
        refresh();

        ThreadUtil.sleep(3000);
    }

    @BeforeEach

        runner.refresh();
        suggester = Suggester.builder().build(runner.client(), "SuggesterTest");
        suggester.createIndexIfNothing();
    }

    @Test
    public void test_indexAndSuggest() throws Exception {
        SuggestItem[] items = getItemSet1();
        suggester.indexer().index(items);
        suggester.refresh();

        // Refresh should clear the cache
        auth.refresh();
        Subject afterRefresh = auth.getSubject();
        // After refresh, may succeed or fail depending on JAAS configuration
        // Just verify that refresh doesn't break the authenticator
        assertNotNull(auth, "Authenticator should remain usable after refresh");
    }

    @Test

            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Silent token refresh failed: {}", e.getMessage());
                }
            }
            // For MSAL4J, if silent refresh fails, return true if token is still valid
            // Actual refresh will happen during next authentication request
            return true;
        }

        /**

     */
    public void deleteBadWord(final String badWord) {
        suggester.indexer().deleteBadWord(badWord);
        refresh();
    }

    /**
     * Refreshes the suggest index.
     */
    public synchronized void refresh() {
        suggester.refresh();
        if (popularWordHelper != null) {
            popularWordHelper.clearCache();
        }
    }

    /**

    assertEquals(Integer.valueOf(2), cache.getUnchecked(2));
    assertEquals(expectedLoads, loader.getLoadCount());
    assertEquals(expectedReloads, loader.getReloadCount());

    // refresh 0
    ticker.advance(1, MILLISECONDS);
    assertEquals(Integer.valueOf(1), cache.getUnchecked(0));
    expectedReloads++;
    assertEquals(Integer.valueOf(1), cache.getUnchecked(1));

     * Get the security subject associated with these credentials.
     * @return subject associated with the credentials
     */
    Subject getSubject();

    /**
     * Refresh the credentials.
     * @throws CIFSException if refresh fails
     */
    void refresh() throws CIFSException;

        }
    }

    @Test
    @DisplayName("refresh succeeds when not configured to fail")
    void refresh_success() throws Exception {
        TestCredentials creds = new TestCredentials("Z", false, false, new Subject(), false);
        // Should not throw
        assertDoesNotThrow(creds::refresh);
    }

    @Test
    @DisplayName("refresh throws CIFSException when configured to fail")

    }

    public void test_refresh() {
        List<LabelType> labelTypeList = createTestLabelTypeList();

        try {
            labelTypeHelper.refresh(labelTypeList);
        } catch (Exception e) {
            fail("refresh() should not throw an exception: " + e.getMessage());
        }
    }

    public void test_matchLocale() {