*/
  <T extends @NonNull B> @Nullable T getInstance(Class<T> type);

  /**
   * Returns the value the specified type is mapped to, or {@code null} if no entry for this type is
   * present. This will only return a value that was bound to this specific type, not a value that
   * may have been bound to a subtype.
   */
  <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type);

  /**

    checkNotNull(valueComparator);
    return Comparator.<Optional<T>, @Nullable T>comparing(
        o -> orElseNull(o), Comparator.nullsLast(valueComparator));
  }

  // For discussion of why this exists, see the Android flavor.
  private static <T> @Nullable T orElseNull(Optional<T> optional) {
    return optional.orElse(null);
  }

  /**

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractBiMapTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMapTester<K, V> {

  @Override
  protected BiMap<K, V> getMap() {
    return (BiMap<K, V>) super.getMap();
  }

  static <K extends @Nullable Object, V extends @Nullable Object> Entry<V, K> reverseEntry(
      Entry<K, V> entry) {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public class SortedSetNavigationTester<E extends @Nullable Object> extends AbstractSetTester<E> {

  private SortedSet<E> sortedSet;
  private List<E> values;
  private @Nullable E a;
  private @Nullable E b;
  private @Nullable E c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    sortedSet = (SortedSet<E>) getSet();

  private static final @Nullable Object jla = getJla();

  /**
   * The "getStackTraceElementMethod" method, only available on some JDKs so we use reflection to
   * find it when available. When this is null, use the slow way.
   */
  @J2ktIncompatible @GwtIncompatible // java.lang.reflect
  private static final @Nullable Method getStackTraceElementMethod =

   * PeekingIterator#remove()} removes the same elements as the reference's iterator {@code
   * remove()}.
   */
  private static class PeekingIteratorTester<T extends @Nullable Object> extends IteratorTester<T> {
    private final Iterable<T> master;
    private @Nullable List<T> targetList;

    PeekingIteratorTester(Collection<T> master) {
      super(master.size() + 3, MODIFIABLE, master, IteratorTester.KnownOrder.KNOWN_ORDER);

 *
 * @author Louis Wasserman
 */
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashSet<E extends @Nullable Object> extends CompactHashSet<E> {

  /** Creates an empty {@code CompactLinkedHashSet} instance. */
  public static <E extends @Nullable Object> CompactLinkedHashSet<E> create() {
    return new CompactLinkedHashSet<>();
  }

  /**

 *
 * @author Louis Wasserman
 */
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashSet<E extends @Nullable Object> extends CompactHashSet<E> {

  /** Creates an empty {@code CompactLinkedHashSet} instance. */
  public static <E extends @Nullable Object> CompactLinkedHashSet<E> create() {
    return new CompactLinkedHashSet<>();
  }

  /**

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Unit test for {@link AbstractCache}.
 *
 * @author Charles Fry
 */
@NullUnmarked
public class AbstractCacheTest extends TestCase {

  public void testGetIfPresent() {

import java.util.concurrent.Future;
import org.jspecify.annotations.Nullable;

/**
 * Transforms a value, possibly asynchronously. For an example usage and more information, see
 * {@link Futures#transformAsync(ListenableFuture, AsyncFunction, Executor)}.
 *
 * @author Chris Povirk
 * @since 11.0
 */
@GwtCompatible
public interface AsyncFunction<I extends @Nullable Object, O extends @Nullable Object> {
  /**