}

  @Override
  public void invalidateAll() {
    delegate().invalidateAll();
  }

  @Override
  public long size() {
    return delegate().size();
  }

  @Override
  public CacheStats stats() {
    return delegate().stats();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    return delegate().asMap();
  }

  @Override
  public void cleanUp() {

    LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader());
    assertThat(cache.stats()).isEqualTo(EMPTY_STATS);

    Object one = new Object();
    cache.getUnchecked(one);
    CacheStats stats = cache.stats();
    assertThat(stats.requestCount()).isEqualTo(1);
    assertThat(stats.hitCount()).isEqualTo(0);
    assertThat(stats.hitRate()).isEqualTo(0.0);
    assertThat(stats.missCount()).isEqualTo(1);

            @Override
            public void recordEviction() {}

            @Override
            public CacheStats snapshot() {
              return EMPTY_STATS;
            }
          });
  static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);

  /*
   * We avoid using a method reference or lambda here for now:
   *

      assertWithMessage("Invalid removal notification")
          .that(notification.getValue())
          .isEqualTo(notification.getKey());
    }

    CacheStats stats = cache.stats();
    assertThat(stats.evictionCount()).isEqualTo(removalListener.size());
    assertThat(stats.loadSuccessCount()).isEqualTo(computeCount.get());

    public long size() {
      return localCache.longSize();
    }

    @Override
    public ConcurrentMap<K, V> asMap() {
      return localCache;
    }

    @Override
    public CacheStats stats() {
      SimpleStatsCounter aggregator = new SimpleStatsCounter();
      aggregator.incrementBy(localCache.globalStatsCounter);
      for (Segment<K, V> segment : localCache.segments) {