assertThat(containsKey(cache, 2)).isTrue();
  }

  @Test
  public void invalidateAll() {
    Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build();

    cache.put(654, 2675);
    cache.put(2456, 56);
    cache.put(2, 15);

    cache.invalidateAll();
    assertThat(containsKey(cache, 654)).isFalse();
    assertThat(containsKey(cache, 2456)).isFalse();
    assertThat(containsKey(cache, 2)).isFalse();

    assertThat(containsKey(cache, 2)).isTrue();
  }

  @Test
  public void invalidateAll() {
    Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build();

    cache.put(654, 2675);
    cache.put(2456, 56);
    cache.put(2, 15);

    cache.invalidateAll();
    assertThat(containsKey(cache, 654)).isFalse();
    assertThat(containsKey(cache, 2456)).isFalse();
    assertThat(containsKey(cache, 2)).isFalse();

      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      cache.invalidate(key1);
      assertThat(cache.asMap().containsKey(key1)).isFalse();
      assertThat(cache.asMap().containsKey(key2)).isTrue();
      assertThat(cache.size()).isEqualTo(1);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key2));
      assertThat(cache.asMap().values()).contains(value2);

      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      cache.invalidate(key1);
      assertThat(cache.asMap().containsKey(key1)).isFalse();
      assertThat(cache.asMap().containsKey(key2)).isTrue();
      assertThat(cache.size()).isEqualTo(1);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key2));
      assertThat(cache.asMap().values()).contains(value2);

      this.backingMap = backingMap;
    }

    @Override
    protected Map<K, V> delegate() {
      return backingMap;
    }

    @Override
    public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override

    }

    @Override
    public void clear() {
      assertTrue(Thread.holdsLock(mutex));
      super.clear();
    }

    @Override
    public boolean containsKey(Object key) {
      assertTrue(Thread.holdsLock(mutex));
      return super.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.containsValue(value);
    }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapInclusive() {
    assertTrue(navigableMap.tailMap(a.getKey()).containsKey(a.getKey()));
  }

  public void testHeadMap() {
    List<Entry<K, V>> entries =
        copyToList(

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapInclusive() {
    assertTrue(navigableMap.tailMap(a.getKey()).containsKey(a.getKey()));
  }

  public void testHeadMap() {
    List<Entry<K, V>> entries =
        copyToList(

    }

    @Override
    public void clear() {
      assertTrue(Thread.holdsLock(mutex));
      super.clear();
    }

    @Override
    public boolean containsKey(Object key) {
      assertTrue(Thread.holdsLock(mutex));
      return super.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.containsValue(value);
    }

      this.rowKey = checkNotNull(rowKey);
    }

    @Nullable Map<C, V> backingRowMap;

    final void updateBackingRowMapField() {
      if (backingRowMap == null || (backingRowMap.isEmpty() && backingMap.containsKey(rowKey))) {
        backingRowMap = computeBackingRowMap();
      }
    }

    @Nullable Map<C, V> computeBackingRowMap() {
      return backingMap.get(rowKey);
    }