.removalListener(listener)
            .build(constantLoader(computed));

    Object key = new Object();
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(computed);
    RemovalNotification<Object, Object> notification = listener.remove();
    assertThat(notification.getKey()).isSameInstanceAs(key);
    assertThat(notification.getValue()).isSameInstanceAs(computed);

  }

  public void testComputeIfPresentRemove() {
    List<RemovalNotification<Integer, Integer>> notifications = new ArrayList<>();
    Cache<Integer, Integer> cache =
        CacheBuilder.newBuilder()
            .removalListener((RemovalNotification<Integer, Integer> n) -> notifications.add(n))
            .build();
    cache.put(1, 2);

  }

  /** {@link RemovalListener} that adds all {@link RemovalNotification} objects to a queue. */
  @J2ktIncompatible
  @GwtIncompatible // ConcurrentLinkedQueue
  static class QueuingRemovalListener<K, V> extends ConcurrentLinkedQueue<RemovalNotification<K, V>>
      implements RemovalListener<K, V> {

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      add(notification);
    }
  }

import org.lastaflute.di.core.factory.SingletonLaContainerFactory;
import org.lastaflute.job.LaJobRuntime;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.RemovalNotification;

import groovy.lang.Binding;
import groovy.lang.GroovyClassLoader;
import groovy.lang.Script;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

/**

    // contain the computed value (b -> b), since the clear() happened before the computation
    // completed.
    assertThat(listener).hasSize(1);
    RemovalNotification<String, String> notification = listener.remove();
    assertThat(notification.getKey()).isEqualTo("a");
    assertThat(notification.getValue()).isEqualTo("a");
    assertThat(cache.size()).isEqualTo(1);

    // contain the computed value (b -> b), since the clear() happened before the computation
    // completed.
    assertThat(listener).hasSize(1);
    RemovalNotification<String, String> notification = listener.remove();
    assertThat(notification.getKey()).isEqualTo("a");
    assertThat(notification.getValue()).isEqualTo("a");
    assertThat(cache.size()).isEqualTo(1);

    assertThat(map.values().removeAll(ImmutableSet.of("bar"))).isTrue();
    assertThat(map).hasSize(1);
  }

  public void testComputeIfAbsent_removalListener() {
    List<RemovalNotification<Object, Object>> notifications = new ArrayList<>();
    RemovalListener<Object, Object> removalListener = notifications::add;
    Cache<Object, Object> cache =

    assertThat(listener.isEmpty()).isTrue();
  }

  static <K, V> void assertNotified(
      QueuingRemovalListener<K, V> listener, K key, V value, RemovalCause cause) {
    RemovalNotification<K, V> notification = listener.remove();
    assertThat(notification.getKey()).isSameInstanceAs(key);
    assertThat(notification.getValue()).isSameInstanceAs(value);

      totalWeight -= weight;
      if (cause.wasEvicted()) {
        statsCounter.recordEviction();
      }
      if (map.removalNotificationQueue != DISCARDING_QUEUE) {
        RemovalNotification<K, V> notification = RemovalNotification.create(key, value, cause);
        map.removalNotificationQueue.offer(notification);
      }
    }

    /**

    boolean removal = (maximumSize == LocalCache.UNSET_INT) ? false : (size() > maximumSize);
    if ((removalListener != null) && removal) {
      removalListener.onRemoval(
          RemovalNotification.create(
              ignored.getKey(), ignored.getValue().getValue(), RemovalCause.SIZE));
    }
    statsCounter.recordEviction();
    return removal;
  }