assertTrue(Thread.holdsLock(mutex));
      return delegate.removeLast();
    }

    @Override
    public @Nullable E pollFirst() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.pollFirst();
    }

    @Override
    public @Nullable E pollLast() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.pollLast();
    }

    @Override

                    @Nonnull Session session,
                    @Nullable RequestTrace trace,
                    @Nullable Path path,
                    @Nullable Source source,
                    boolean allowStubModel,
                    boolean recursive,
                    boolean processPlugins,
                    @Nullable List<RemoteRepository> repositories) {
                super(session, trace);

      this.entryIterable = (Iterable) entryIterable;
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      return get(key) != null;
    }

    @Override
    public @Nullable V get(@Nullable Object key) {
      if (key instanceof Range) {
        Range<?> range = (Range<?>) key;

 */
public abstract class LookupInvoker<C extends LookupContext> implements Invoker {
    protected final Lookup protoLookup;

    @Nullable
    protected final Consumer<LookupContext> contextConsumer;

    public LookupInvoker(Lookup protoLookup, @Nullable Consumer<LookupContext> contextConsumer) {
        this.protoLookup = requireNonNull(protoLookup);
        this.contextConsumer = contextConsumer;
    }

  @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) {

 * @author George van den Driessche
 */
@GwtCompatible
@NullMarked
public class AbstractTester<G> extends TestCase {
  private G subjectGenerator;
  private String suiteName;
  private @Nullable Runnable setUp;
  private @Nullable Runnable tearDown;

  // public so that it can be referenced in generated GWT tests.
  @Override
  public void setUp() throws Exception {
    if (setUp != null) {
      setUp.run();
    }
  }

 * @author George van den Driessche
 */
@GwtCompatible
@NullMarked
public class AbstractTester<G> extends TestCase {
  private G subjectGenerator;
  private String suiteName;
  private @Nullable Runnable setUp;
  private @Nullable Runnable tearDown;

  // public so that it can be referenced in generated GWT tests.
  @Override
  public void setUp() throws Exception {
    if (setUp != null) {
      setUp.run();
    }
  }

      new IteratorOperation() {
        @Override
        public @Nullable Object execute(Iterator<?> iterator) {
          iterator.remove();
          return null;
        }
      };

  private static final IteratorOperation NEXT_METHOD =
      new IteratorOperation() {
        @Override
        public @Nullable Object execute(Iterator<?> iterator) {
          return iterator.next();
        }

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

  /**

 * @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

  /**