this.active = true;
        }

        /**
         * Gets the path of the directory being monitored
         * @return the directory path
         */
        public String getDirectoryPath() {
            return directoryPath;
        }

        /**
         * Gets the lease key associated with this notification handle
         * @return the lease key
         */

            System.clearProperty(testKey);
        }
    }

    // Test multiple gets with different keys
    public void test_get_multipleKeys() {
        // Test getting multiple different properties
        String value1 = fessConfig.get("domain.title");
        String value2 = fessConfig.get("search_engine.type");

        assertEquals("Test Fess", value1);
        assertEquals("opensearch", value2);

    public boolean containsValue(final Object value) {
        return parent.containsValue(value);
    }

    @Override
    public V get(final Object key) {
        final V value = parent.get(key);
        if (value != null) {
            return value;
        }
        return parent.get(toCamelCase(key));
    }

    @Override
    public V put(final K key, final V value) {
        return parent.put(key, value);

        }

        /**
         * Gets a cache key for this FTP connection based on host and port.
         * This key can be used to cache FTP client connections.
         *
         * @return The cache key in format "host:port"
         */
        public String getCacheKey() {
            return getHost() + ":" + getPort();
        }

        /**
         * Gets the host name from the FTP URL.
         *

@Experimental
public interface DependencyResolverResult extends Result<DependencyResolverRequest> {

    /**
     * Gets the exceptions that occurred while building the dependency graph.
     *
     * @return the exceptions that occurred, never {@code null}
     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the root node of the dependency graph.
     *

   */
  interface InternalEntry<K, V, E extends InternalEntry<K, V, E>> {
    /** Gets the next entry in the chain. */
    E getNext();

    /** Gets the entry's hash. */
    int getHash();

    /** Gets the key for this entry. */
    K getKey();

    /** Gets the value for the entry. */
    V getValue();
  }

  /*

    @Override
    public List<Pattern> getIncludeUrlPatternList(final String sessionId) {
        try {
            return includeFilterCache.get(sessionId);
        } catch (final ExecutionException e) {
            throw new CrawlerSystemException(e);
        }
    }

    /**
     * Gets the list of exclude URL patterns for the specified session.
     *
     * @param sessionId The session ID.

    // A task should have been scheduled
    assertTrue(fakePool.hasNext());
    e.execute(intCounter);
    // Our executor hasn't run any tasks yet.
    assertEquals(0, totalCalls.get());
    fakePool.runAll();
    assertEquals(2, totalCalls.get());
    // Queue is empty so no runner should be scheduled.
    assertFalse(fakePool.hasNext());

    // Check that execute can be safely repeated
    e.execute(intCounter);

     */

    /**
     * Gets the local host NetBIOS address.
     *
     * @return the local host address
     * @throws UnknownHostException if the local host cannot be determined
     */
    public static NbtAddress getLocalHost() throws UnknownHostException {
        return localhost;
    }

    /**
     * Gets the local host NetBIOS name.
     *

        });
    }

    /**
     * Gets a web configuration by its ID.
     *
     * @param id The ID of the web configuration
     * @return Optional containing the web configuration if found
     */
    public OptionalEntity<WebConfig> getWebConfig(final String id) {
        return webConfigBhv.selectByPK(id);
    }

    /**
     * Gets a web configuration by its name.