public boolean isEmpty() {
      synchronized (mutex) {
        return delegate().isEmpty();
      }
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      synchronized (mutex) {
        return delegate().containsKey(key);
      }
    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      synchronized (mutex) {

 * 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

    for (Object key : lookupKeys) {
      assertThat(cache.asMap().containsKey(key)).isTrue();
    }
    assertThat(cache.asMap().get(extraKey)).isSameInstanceAs(extraValue);
    assertThat(cache.asMap().containsKey(extraValue)).isFalse();
  }

  public void testBulkLoad_clobberNullKey() throws ExecutionException {
    Object extraKey = new Object();

      }
      next = CompactHashing.getNext(entry, mask);
    } while (next != UNSET);
    return -1;
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    return (delegate != null) ? delegate.containsKey(key) : indexOf(key) != -1;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();

    return map;
  }

  // Query Operations

  @Override
  public int size() {
    return totalSize;
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return map.containsKey(key);
  }

  // Modification Operations

  @Override
  public boolean put(@ParametricNullness K key, @ParametricNullness V value) {
    Collection<V> collection = map.get(key);

        return put(key, value);
      }
      return null;
    }
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    synchronized (lock) {
      return cachingHashMap.containsKey(key) && !isExpired(cachingHashMap.get(key));
    }
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    synchronized (lock) {

  private static <K, V> void putEntryWithChecks(
      SortedMap<K, V> map, Entry<? extends K, ? extends V> entry) {
    K key = checkNotNull(entry.getKey());
    V value = checkNotNull(entry.getValue());
    if (map.containsKey(key)) {
      // When a collision happens, the colliding entry is the first entry
      // of the tail map.
      Entry<K, V> previousEntry = map.tailMap(key).entrySet().iterator().next();

    for (Object key : lookupKeys) {
      assertThat(cache.asMap().containsKey(key)).isTrue();
    }
    assertThat(cache.asMap().get(extraKey)).isSameInstanceAs(extraValue);
    assertThat(cache.asMap().containsKey(extraValue)).isFalse();
  }

  public void testBulkLoad_clobberNullKey() throws ExecutionException {
    Object extraKey = new Object();

          return getEntry(index);
        }
      };
    }

    // TODO(lowasser): consider an optimized values() implementation

    @Override
    public boolean containsKey(@Nullable Object key) {
      return keyIndex.containsKey(key);
    }

    @Override
    public @Nullable V get(@Nullable Object key) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        return null;

        builder.build(CacheLoader.from(Suppliers.ofInstance(value)));
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(value);
    assertThat(cache.size()).isEqualTo(0);
    assertThat(cache.asMap().containsKey(key)).isFalse();
  }

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