*       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

  @Override
  public <T extends B> @Nullable T putInstance(
      Class<@NonNull T> type, @ParametricNullness T value) {
    return cast(type, put(type, value));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return cast(type, get(type));
  }

  @CanIgnoreReturnValue
  private static <T> @Nullable T cast(Class<T> type, @Nullable Object value) {

      List<@Nullable String> listWithNulls = asList("a", null, "b");
      assertThrows(NullPointerException.class, () -> builder.addAll((List<String>) listWithNulls));
    }

    {
      ImmutableMultiset.Builder<String> builder = ImmutableMultiset.builder();
      Multiset<@Nullable String> multisetWithNull =
          LinkedHashMultiset.create(Arrays.<@Nullable String>asList("a", null, "b"));

 * @param <V> the type of the mapped values
 * @since 7.0
 */
@DoNotMock("Use ImmutableTable, HashBasedTable, or another implementation")
@GwtCompatible
public interface Table<
    R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object> {
  // TODO(jlevy): Consider adding methods similar to ConcurrentMap methods.

  // Accessors

  /**

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@code GeneralRange}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public class GeneralRangeTest extends TestCase {
  private static final Ordering<@Nullable Integer> ORDERING =
      Ordering.<Integer>natural().<Integer>nullsFirst();

  private static final List<@Nullable Integer> IN_ORDER_VALUES =

   */
  public static <T extends @Nullable Object> Iterable<List<@Nullable T>> paddedPartition(
      Iterable<T> iterable, int size) {
    checkNotNull(iterable);
    checkArgument(size > 0);
    return new FluentIterable<List<@Nullable T>>() {
      @Override
      public Iterator<List<@Nullable T>> iterator() {
        return Iterators.paddedPartition(iterable.iterator(), size);

  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @Nullable Comparator<?> comparator, @Nullable Object o1, @Nullable Object o2) {
    if (comparator == null) {
      return ((Comparable<@Nullable Object>) o1).compareTo(o2);
    } else {
      return ((Comparator<@Nullable Object>) comparator).compare(o1, o2);
    }
  }

  /**

  @Override
  public @Nullable V remove(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.remove(key);
    }
    Object oldValue = removeHelper(key);
    return (oldValue == NOT_FOUND) ? null : (V) oldValue;
  }

  private @Nullable Object removeHelper(@Nullable Object key) {
    if (needsAllocArrays()) {

   */

  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

   * not have been inserted consecutively.
   */
  private final @Nullable List<NodeConnection<N>> orderedNodeConnections;

  private int predecessorCount;
  private int successorCount;

  private DirectedGraphConnections(
      Map<N, Object> adjacentNodeValues,
      @Nullable List<NodeConnection<N>> orderedNodeConnections,
      int predecessorCount,
      int successorCount) {