* 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;

    }

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

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

        while (idList.size() > 0 && count < NUM) {
            final String id = idList.get(0);
            checkDeleteMethod(getItemEndpointSuffix() + "/" + id.toString());
            refresh();
            idList = getIdList(searchBody);
            count += 1;
        }
    }

    @AfterAll
    protected static void tearDownAll() {
        deleteTestToken();
    }

        return numOfDeleted;
    }

    /**
     * Refreshes the specified index to make recent changes visible for search.
     * This operation ensures that all pending writes are persisted and searchable.
     *
     * @param searchEngineClient the search engine client to use for refresh
     * @param index the index name to refresh
     * @return the refresh status code
     */

     */
    default boolean isEditable() {
        return false;
    }

    /**
     * Refreshes the user's information from the underlying data source.
     * @return True if refresh was successful, false otherwise.
     */
    default boolean refresh() {
        return false;
    }

	ll *localLocker
}

// RefreshHandler - refresh the current lock
func (l *lockRESTServer) RefreshHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	// Add a timeout similar to what we expect upstream.
	ctx, cancel := context.WithTimeout(context.Background(), dsync.DefaultTimeouts.RefreshCall)
	defer cancel()

	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(ctx, *args)
	if err != nil {

     * This cache is refreshed periodically based on the lastLoadedTime.
     */
    protected String[] dataStoreNames = StringUtil.EMPTY_STRINGS;

    /**
     * Timestamp of the last time data store names were loaded from plugin files.
     * Used to implement a time-based cache refresh mechanism.
     */
    protected long lastLoadedTime = 0;

    /**

            op.setRefreshPolicy(Constants.TRUE);
        });

        final LabelTypeHelper labelTypeHelper = ComponentUtil.getLabelTypeHelper();
        if (labelTypeHelper != null) {
            labelTypeHelper.refresh(getLabelTypeList());
        }
    }

    /**
     * Set up list conditions.
     *
     * @param cb The condition bean.
     * @param labelTypePager The pager for label types.
     */

     * @return true if expired
     */
    public boolean isExpired() {
        return System.currentTimeMillis() - lastUpdateTime > maxAge;
    }

    /**
     * Check if cache needs refresh
     *
     * @return true if refresh needed
     */
    public boolean needsRefresh() {
        return isExpired() || hasChanges;
    }

    /**
     * Mark the cache as complete (full enumeration cached)
     */