int expectedSize) {
    return new CompactLinkedHashSet<>(expectedSize);
  }

  private static final int ENDPOINT = -2;

  // TODO(user): predecessors and successors should be collocated (reducing cache misses).
  // Might also explore collocating all of [hash, next, predecessor, successor] fields of an
  // entry in a *single* long[], though that reduces the maximum size of the set by a factor of 2

  /**

import org.codelibs.fess.util.ComponentUtil;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public class PopularWordHelper {
    private static final Logger logger = LogManager.getLogger(PopularWordHelper.class);

    protected static final char CACHE_KEY_SPLITTER = '\n';

    protected Cache<String, List<String>> cache;

    protected FessConfig fessConfig;

    @PostConstruct

        } else {
            if (anew) {
                cache = new ConcurrentHashMap<>();
                repositoryCache.put(session, KEY, cache);
            } else {
                cache = (ConcurrentHashMap<Object, Supplier<?>>)
                        repositoryCache.computeIfAbsent(session, KEY, ConcurrentHashMap::new);
            }
            return new DefaultModelCache(cache);
        }
    }

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;

class DefaultProjectArtifactsCacheTest {

    private ProjectArtifactsCache cache;

    @BeforeEach
    void setUp() throws Exception {
        cache = new DefaultProjectArtifactsCache();
    }

    @Test
    void testProjectDependencyOrder() throws Exception {

import java.util.Set;
import java.util.function.Predicate;

import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.PathType;

/**
 * Cache of {@link PathModularization} instances computed for given {@link Path} elements.
 * The cache is used for avoiding the need to reopen the same files many times when the
 * same dependency is used for different scope. For example a path used for compilation

  public SampleElements<Entry<String, String>> samples() {
    return new SampleElements<>(
        Helpers.mapEntry("one", "January"),
        Helpers.mapEntry("two", "February"),
        Helpers.mapEntry("three", "March"),
        Helpers.mapEntry("four", "April"),
        Helpers.mapEntry("five", "May"));
  }

  @Override
  public SampleElements<String> sampleKeys() {

 * the License.
 */

package com.google.common.cache;

import com.google.common.base.Function;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.LocalCache.Strength;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;

  public SampleElements<Entry<AnEnum, String>> samples() {
    return new SampleElements<>(
        Helpers.mapEntry(AnEnum.A, "January"),
        Helpers.mapEntry(AnEnum.B, "February"),
        Helpers.mapEntry(AnEnum.C, "March"),
        Helpers.mapEntry(AnEnum.D, "April"),
        Helpers.mapEntry(AnEnum.E, "May"));
  }

  @Override
  public final Map<AnEnum, String> create(Object... entries) {
    @SuppressWarnings("unchecked")

  public SampleElements<Entry<AnEnum, String>> samples() {
    return new SampleElements<>(
        Helpers.mapEntry(AnEnum.A, "January"),
        Helpers.mapEntry(AnEnum.B, "February"),
        Helpers.mapEntry(AnEnum.C, "March"),
        Helpers.mapEntry(AnEnum.D, "April"),
        Helpers.mapEntry(AnEnum.E, "May"));
  }

  @Override
  public final Map<AnEnum, String> create(Object... entries) {
    @SuppressWarnings("unchecked")

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.cache;

import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.Constants;
import org.codelibs.fess.app.web.base.FessSearchAction;