@Generates
  static <K, V> Map<K, V> generateMap(@Nullable K key, @Nullable V value) {
    return generateHashdMap(key, value);
  }

  @Generates
  static <K, V> HashMap<K, V> generateHashdMap(@Nullable K key, @Nullable V value) {
    return generateLinkedHashMap(key, value);
  }

  @Generates
  static <K, V> LinkedHashMap<K, V> generateLinkedHashMap(@Nullable K key, @Nullable V value) {

   * 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 Iterable<T> master;
    private @Nullable List<T> targetList;

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

  @Override
  public <S extends Comparable<?>> Ordering<@Nullable S> nullsFirst() {
    Ordering<@Nullable Comparable<?>> result = nullsFirst;
    if (result == null) {
      result = nullsFirst = super.<Comparable<?>>nullsFirst();
    }
    return (Ordering<@Nullable S>) result;
  }

  @Override
  public <S extends Comparable<?>> Ordering<@Nullable S> nullsLast() {
    Ordering<@Nullable Comparable<?>> result = nullsLast;

  public <S extends @Nullable T> Ordering<S> reverse() {
    // ordering.reverse() might be optimized, so let it do its thing
    return ordering.<T>reverse().<@NonNull S>nullsLast();
  }

  @SuppressWarnings("unchecked") // still need the right way to explain this
  @Override
  public <S extends @Nullable T> Ordering<@Nullable S> nullsFirst() {
    return (Ordering<@Nullable S>) this;
  }

  @Override

 *     Object}, or use {@code @Nullable Object} to allow null values.
 * @since 2.0
 */
@DoNotMock("Use ImmutableClassToInstanceMap or MutableClassToInstanceMap")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface ClassToInstanceMap<B extends @Nullable Object>
    extends Map<Class<? extends @NonNull B>, B> {
  /**

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * To be implemented by test generators that can produce test subjects without requiring any
 * parameters.
 *
 * @param <T> the type created by this generator.
 * @author George van den Driessche
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestSubjectGenerator<T extends @Nullable Object> {
  T createTestSubject();

  @VisibleForTesting final transient @Nullable Object[] array;
  private final transient int size;

  RegularImmutableList(@Nullable Object[] array, int size) {
    this.array = array;
    this.size = size;
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  @Nullable
  Object[] internalArray() {

     * @return The interpolated string, or null if the input was null.
     */
    @Nullable
    String interpolate(
            @Nullable String val,
            @Nullable Function<String, String> callback,
            @Nullable BiFunction<String, String, String> postprocessor,
            boolean defaultsToEmpty);

    /**

    List<@Nullable Integer> list4 = Lists.newArrayList(1, 2);
    List<@Nullable Integer> list5 = Lists.newArrayList(1, null, 2);
    List<@Nullable Integer> list6 = Lists.newArrayList(2);
    List<@Nullable Integer> list7 = Lists.newArrayList(nullInt);
    List<@Nullable Integer> list8 = Lists.newArrayList(nullInt, nullInt);
    List<@Nullable List<@Nullable Integer>> list =

    List<@Nullable Integer> list4 = Lists.newArrayList(1, 2);
    List<@Nullable Integer> list5 = Lists.newArrayList(1, null, 2);
    List<@Nullable Integer> list6 = Lists.newArrayList(2);
    List<@Nullable Integer> list7 = Lists.newArrayList(nullInt);
    List<@Nullable Integer> list8 = Lists.newArrayList(nullInt, nullInt);
    List<@Nullable List<@Nullable Integer>> list =