return sval;
    }

    /**
     * Advances to the next token.
     *
     * @return The type of the token.
     */
    public int nextToken() {
        initVal();
        if (processEOF()) {
            return ttype;
        }
        if (processWhitespace()) {
            return ttype;
        }
        if (processWord()) {
            return ttype;

    }

    /**
     * Creates and returns an initial context.
     *
     * @return the initial context
     */
    public static InitialContext create() {
        try {
            return new InitialContext();
        } catch (final NamingException ex) {
            throw new NamingRuntimeException(ex);
        }
    }

    /**
     * Creates and returns an initial context using the specified environment.
     *

     *
     * @param <E> the element type of {@link ArrayBlockingQueue}
     * @param capacity the queue capacity
     * @param fair whether the queue is fair
     * @param c the collection of initial elements
     * @return a new instance of {@link ArrayBlockingQueue}
     * @see ArrayBlockingQueue#ArrayBlockingQueue(int, boolean, Collection)
     */

     * shouldn't)
     *
     * Our solution is for threads to CAS seenExceptionsField from null to a Set populated with _the
     * initial exception_, no matter which thread does the work. This ensures that
     * seenExceptionsField always contains not just the current thread's exception but also the
     * initial thread's.
     */
    Set<Throwable> seenExceptionsLocal = seenExceptionsField;
    if (seenExceptionsLocal == null) {

        String originalValue = System.getProperty(Constants.FESS_SEARCH_ENGINE_HTTP_ADDRESS);

        try {
            // Set initial value
            System.setProperty(Constants.FESS_SEARCH_ENGINE_HTTP_ADDRESS, "initial");
            assertEquals("initial", SystemUtil.getSearchEngineHttpAddress());

            // Change value and verify it's read fresh

 * @param <K> the key type
 * @param <V> the value type
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = 1L;

    /**
     * Default initial capacity.
     */
    protected static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * Default load factor.
     */
    protected static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**

   *
   * @throws IllegalArgumentException if {@code initialCapacity} is negative
   * @throws IllegalStateException if an initial capacity was already set
   */
  @CanIgnoreReturnValue
  public MapMaker initialCapacity(int initialCapacity) {
    checkState(
        this.initialCapacity == UNSET_INT,
        "initial capacity was already set to %s",
        this.initialCapacity);
    checkArgument(initialCapacity >= 0);

                return execTime.get();
            }

            @Override
            public void commit() {
                // No-op for test
            }
        };

        // Test initial state
        assertEquals(0L, callback.getDocumentSize());
        assertEquals(0L, callback.getExecuteTime());

        // Test store method
        DataStoreParams params = new DataStoreParams();

    public void test_get_cacheAfterSystemPropertyChange() {
        String testKey = "cache.test";
        String initialValue = "initial";
        System.setProperty(Constants.FESS_CONFIG_PREFIX + testKey, initialValue);

        try {
            // Get initial value
            String value1 = fessConfig.get(testKey);
            assertEquals(initialValue, value1);

            // Change system property

        List<RelatedContent> testData = new ArrayList<>();
        testData.add(createRelatedContent("test", "Initial Content", ""));
        mockBhv.setTestData(testData);

        relatedContentHelper.load();
        String[] results = relatedContentHelper.getRelatedContents("test");
        assertEquals("Initial Content", results[0]);

        // Update test data
        testData.clear();