@Nonnull ProtoSession session,
                    @Nullable RequestTrace trace,
                    @Nullable Source installationSettingsSource,
                    @Nullable Source projectSettingsSource,
                    @Nullable Source userSettingsSource,
                    @Nullable UnaryOperator<String> interpolationSource) {
                super(session, trace);

 * @author Ben Yu
 * @since 12.0
 */
/*
 * A nullable bound would let users create a TypeParameter instance for a parameter with a nullable
 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which
 * wouldn't behave as users might expect. Additionally, it's not clear how the TypeToken API could
 * support even a "normal" `TypeParameter<T>` when `<T>` has a nullable bound. (See the discussion

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link Functions}.
 *
 * @author Mike Bostock
 * @author Vlad Patryshev
 */
@GwtCompatible
@NullMarked
public class FunctionsTest extends TestCase {

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();

    private @Nullable Set<@Nullable N> visitedNodes;

    private Undirected(BaseGraph<N> graph) {
      super(graph);
      this.visitedNodes = Sets.newHashSetWithExpectedSize(graph.nodes().size() + 1);
    }

    @Override
    protected @Nullable EndpointPair<N> computeNext() {
      while (true) {
        /*

@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();

import com.google.common.base.Predicate;
import java.util.List;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link Multimaps#filterKeys(ListMultimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class FilteredKeyListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends FilteredKeyMultimap<K, V> implements ListMultimap<K, V> {

   *
   * @since 7.0
   */
  @Override
  protected boolean standardContains(@Nullable Object object) {
    try {
      // any ClassCastExceptions and NullPointerExceptions are caught
      @SuppressWarnings({"unchecked", "nullness"})
      SortedSet<@Nullable Object> self = (SortedSet<@Nullable Object>) this;
      Object ceiling = self.tailSet(object).first();

   */

  static final class Node<K extends @Nullable Object, V extends @Nullable Object>
      extends SimpleEntry<K, V> {
    @Nullable Node<K, V> next; // the next node (with any key)
    @Weak @Nullable Node<K, V> previous; // the previous node (with any key)
    @Nullable Node<K, V> nextSibling; // the next node with the same key
    @Weak @Nullable Node<K, V> previousSibling; // the previous node with the same key

        return backingMap.size();
      }

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

  // Internal methods (package-visible, but treat as only subclass-visible)

  @Nullable V getIfCached(@Nullable Object key) {
    Entry<K, V> entry = cacheEntry; // store local reference for thread-safety