/**
     * Wrapper for managed resources
     */
    public static class ManagedResource<T extends AutoCloseable> implements AutoCloseable {
        private final T resource;
        private final String resourceId;
        private final ResourceManager manager;
        private volatile boolean closed = false;

        ManagedResource(T resource, String resourceId, ResourceManager manager) {

 *
 * {@snippet :
 * class Server {
 *   public static void main(String[] args) {
 *     Set<Service> services = ...;
 *     ServiceManager manager = new ServiceManager(services);
 *     manager.addListener(new Listener() {
 *         public void stopped() {}
 *         public void healthy() {
 *           // Services have been initialized and are healthy, start accepting requests...

        assertTrue(fessUserBean.hasGroups(new String[] { "managers", "developers" }));

        // Test with no matching groups
        assertFalse(fessUserBean.hasGroups(new String[] { "managers", "guests" }));

        // Test with multiple groups
        testUser.setGroupNames(new String[] { "developers", "testers", "managers" });
        assertTrue(fessUserBean.hasGroups(new String[] { "developers" }));

    }

    /**
     * Array of registered web API managers.
     */
    protected WebApiManager[] webApiManagers = {};

    /**
     * Adds a web API manager to the factory.
     *
     * @param webApiManager The web API manager to add
     */
    public void add(final WebApiManager webApiManager) {
        final List<WebApiManager> list = new ArrayList<>();
        Collections.addAll(list, webApiManagers);

    /**
     * Default constructor for DictionaryManager.
     * Creates a new dictionary manager with an empty creator list.
     */
    public DictionaryManager() {
        // Default constructor
    }

    /**
     * Initializes the dictionary manager after construction.
     * Sets up the relationship between this manager and all registered creators.
     */
    @PostConstruct
    public void init() {

    public Date getTimestamp() {
        return timestamp;
    }

    /**
     * Sets the dictionary manager for this file and returns this instance.
     *
     * @param dictionaryManager the dictionary manager to set
     * @return this dictionary file instance for method chaining
     */
    public DictionaryFile<T> manager(final DictionaryManager dictionaryManager) {
        this.dictionaryManager = dictionaryManager;

## Context Managers { #context-managers }

### What are "Context Managers" { #what-are-context-managers }

"Context Managers" are any of those Python objects that you can use in a `with` statement.

      else -> InsecureExtendedTrustManager(trustManager as X509ExtendedTrustManager, insecureHosts)
    }
  }

  /**
   * Returns a key manager for the held certificate and its chain. Returns an empty key manager if
   * `heldCertificate` is null.
   */
  @JvmStatic
  fun newKeyManager(
    keyStoreType: String?,
    heldCertificate: HeldCertificate?,
    vararg intermediates: X509Certificate,
  ): X509KeyManager {

     */
    public ProtwordsCreator() {
        super("protwords.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager.
     * This method is called automatically after construction to add this creator to the dictionary manager.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Load {}", this.getClass().getSimpleName());

    }

    @Test
    @DisplayName("Test managed resource wrapper")
    void testManagedResource() throws Exception {
        TestResource resource = new TestResource("test3");

        try (ResourceManager.ManagedResource<TestResource> managed = resourceManager.manage(resource)) {
            assertNotNull(managed.get());
            assertEquals("test3", managed.get().getName());
            assertFalse(resource.isClosed());