shutdownHookList.add(hook);
    }

    public String getHostname() {
        final Map<String, String> env = getEnvMap();
        if (env.containsKey("COMPUTERNAME")) {
            return env.get("COMPUTERNAME");
        }
        if (env.containsKey("HOSTNAME")) {
            return env.get("HOSTNAME");
        }
        try {
            return InetAddress.getLocalHost().getHostAddress();

            }

            final LocalDateTime requestedAt = searchLog.getRequestedAt();
            if (sessionId == null || duplicateSessionMap.containsKey(sessionId)
                    && duplicateSessionMap.get(sessionId).plusMinutes(searchStoreInterval).isAfter(requestedAt)) {
                return;
            }

    LoadingCache<Object, Object> cache =
        builder.build(CacheLoader.from(Suppliers.ofInstance(value)));
    assertSame(value, cache.getUnchecked(key));
    assertEquals(0, cache.size());
    assertFalse(cache.asMap().containsKey(key));
  }

  public void testCacheBuilderFrom_string() {
    CacheBuilder<?, ?> fromString =
        CacheBuilder.from(
            "initialCapacity=10,maximumSize=20,concurrencyLevel=30,"

                break;
            }
        }

        if (documentBoost > 0) {
            addBoostValue(map, documentBoost);
        }

        if (!map.containsKey(fessConfig.getIndexFieldDocId())) {
            map.put(fessConfig.getIndexFieldDocId(), systemHelper.generateDocId(map));
        }

        ComponentUtil.getLanguageHelper().updateDocument(map);
    }

    AsMapOfRanges(Iterable<RangeMapEntry<K, V>> entryIterable) {
      this.entryIterable = (Iterable) entryIterable;
    }

    @Override
    public boolean containsKey(@CheckForNull Object key) {
      return get(key) != null;
    }

    @Override
    @CheckForNull
    public V get(@CheckForNull Object key) {
      if (key instanceof Range) {

        public int size() {
          return adjacentNodeValues.size();
        }

        @Override
        public boolean contains(@CheckForNull Object obj) {
          return adjacentNodeValues.containsKey(obj);
        }
      };
    }
  }

  @Override
  public Set<N> predecessors() {
    return new AbstractSet<N>() {
      @Override
      public UnmodifiableIterator<N> iterator() {

        for (final BeanProperty<Object> property : new BeanProperties(clazz)) {
            final String name = property.getName();
            if (!propertyMap.containsKey(name)) {
                propertyMap.put(name, property);
            }
        }

        while (parser.getEventType() == XmlPullParser.START_TAG) {

 * maintained with a doubly linked list through the entries. All optional operations (put and
 * remove) are supported. Null keys and values are supported.
 *
 * <p>{@code containsKey(k)}, {@code put(k, v)} and {@code remove(k)} are all (expected and
 * amortized) constant time operations. Expected in the hashtable sense (depends on the hash

      if (getHash(entry) == hash && Objects.equal(key, keys[next])) {
        return next;
      }
      next = getNext(entry);
    }
    return -1;
  }

  public boolean containsKey(@CheckForNull Object key) {
    return indexOf(key) != -1;
  }

  public int get(@CheckForNull Object key) {
    int index = indexOf(key);
    return (index == -1) ? 0 : values[index];
  }

    }
    int hash = hash(key);
    return segmentFor(hash).getEntry(key, hash);
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    if (key == null) {
      return false;
    }
    int hash = hash(key);
    return segmentFor(hash).containsKey(key, hash);
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    if (value == null) {