}

  public void testApply() {
    when(mock.apply("key")).thenReturn(Boolean.TRUE);
    assertSame(Boolean.TRUE, forward.apply("key"));
  }

  public void testInvalidate() {
    forward.invalidate("key");
    verify(mock).invalidate("key");
  }

  public void testRefresh() throws ExecutionException {
    forward.refresh("key");
    verify(mock).refresh("key");
  }

  public void testInvalidateAll() {

  override fun getCreationTime(): Long {
    return delegate!!.creationTime
  }

  override fun getLastAccessedTime(): Long {
    return delegate!!.lastAccessedTime
  }

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean {
    return delegate!!.isValid
  }

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }

    assertEquals(
        ImmutableMap.of("key", Boolean.TRUE), forward.getAllPresent(ImmutableList.of("key")));
  }

  public void testInvalidate() {
    forward.invalidate("key");
    verify(mock).invalidate("key");
  }

  public void testInvalidateAllIterable() {
    forward.invalidateAll(ImmutableList.of("key"));
    verify(mock).invalidateAll(ImmutableList.of("key"));
  }

  }


  public void testInvalidate_empty() {
    for (LoadingCache<Object, Object> cache : caches()) {
      cache.getUnchecked("a");
      cache.getUnchecked("b");
      cache.invalidate("a");
      cache.invalidate("b");
      cache.invalidate(0);
      checkEmpty(cache);
    }
  }

  public void testInvalidateAll_empty() {
    for (LoadingCache<Object, Object> cache : caches()) {
      cache.getUnchecked("a");

    assertEquals(
        ImmutableMap.of("key", Boolean.TRUE), forward.getAllPresent(ImmutableList.of("key")));
  }

  public void testInvalidate() {
    forward.invalidate("key");
    verify(mock).invalidate("key");
  }

  public void testInvalidateAllIterable() {
    forward.invalidateAll(ImmutableList.of("key"));
    verify(mock).invalidateAll(ImmutableList.of("key"));
  }

    cache.put(0, 10);

    assertEquals(Integer.valueOf(10), cache.get(0, loader));
    assertEquals(Integer.valueOf(1), cache.get(20, loader));
    assertEquals(Integer.valueOf(2), cache.get(34, loader));

    cache.invalidate(0);
    assertEquals(Integer.valueOf(3), cache.get(0, loader));

    cache.put(0, 10);
    cache.invalidateAll();
    assertEquals(Integer.valueOf(4), cache.get(0, loader));
  }

    cache.invalidateAll(toInvalidate);
    assertEquals(toInvalidate, invalidated);
  }

  public void testEmptySimpleStats() {
    StatsCounter counter = new SimpleStatsCounter();
    CacheStats stats = counter.snapshot();
    assertEquals(0, stats.requestCount());
    assertEquals(0, stats.hitCount());
    assertEquals(1.0, stats.hitRate());
    assertEquals(0, stats.missCount());

            try {
                final StatsObject data = statsCache.getIfPresent(key);
                if (data != null && data.decrement() <= 0) {
                    statsCache.invalidate(key);
                    final Long begin = data.remove(BEGIN_KEY);
                    if (begin != null) {
                        printStats(keyObj, data, begin, true);
                    }
                }

  override fun getValue(s: String): Any {
    throw UnsupportedOperationException()
  }

  override fun getValueNames(): Array<String> {
    throw UnsupportedOperationException()
  }

  override fun invalidate() {
    throw UnsupportedOperationException()
  }

  override fun isValid(): Boolean {
    throw UnsupportedOperationException()
  }

 * {@code get}; {@link #getAllPresent} is implemented in terms of {@code getIfPresent}; {@link
 * #putAll} is implemented in terms of {@link #put}, {@link #invalidateAll(Iterable)} is implemented
 * in terms of {@link #invalidate}. The method {@link #cleanUp} is a no-op. All other methods throw
 * an {@link UnsupportedOperationException}.
 *
 * @author Charles Fry
 * @since 11.0
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault