public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys(int expectedKeys) {
    checkNonnegative(expectedKeys, "expectedKeys");
    return new MultimapBuilderWithKeys<@Nullable Object>() {
      @Override
      <K extends @Nullable Object, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return Platform.newLinkedHashMapWithExpectedSize(expectedKeys);

   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys(int expectedKeys) {
    checkNonnegative(expectedKeys, "expectedKeys");
    return new MultimapBuilderWithKeys<@Nullable Object>() {
      @Override
      <K extends @Nullable Object, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return Platform.newLinkedHashMapWithExpectedSize(expectedKeys);

  private static class UnmodifiableMultimap<K extends @Nullable Object, V extends @Nullable Object>
      extends ForwardingMultimap<K, V> implements Serializable {
    final Multimap<K, V> delegate;
    @LazyInit transient @Nullable Collection<Entry<K, V>> entries;
    @LazyInit transient @Nullable Multiset<K> keys;
    @LazyInit transient @Nullable Set<K> keySet;
    @LazyInit transient @Nullable Collection<V> values;

  private static class UnmodifiableMultimap<K extends @Nullable Object, V extends @Nullable Object>
      extends ForwardingMultimap<K, V> implements Serializable {
    final Multimap<K, V> delegate;
    @LazyInit transient @Nullable Collection<Entry<K, V>> entries;
    @LazyInit transient @Nullable Multiset<K> keys;
    @LazyInit transient @Nullable Set<K> keySet;
    @LazyInit transient @Nullable Collection<V> values;

  public void assertEqualHashCode(
      Predicate<? super @Nullable Integer> expected, Predicate<? super @Nullable Integer> actual) {
    assertEquals(actual + " should hash like " + expected, expected.hashCode(), actual.hashCode());
  }

  public void testHashCodeForBooleanOperations() {
    Predicate<@Nullable Integer> p1 = Predicates.isNull();
    Predicate<@Nullable Integer> p2 = isOdd();

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

     * @param defaultReply the default reply value
     * @return the string entered by the user
     * @throws PrompterException if an exception occurs
     */
    @Nonnull
    String prompt(@Nullable String message, @Nullable List<String> possibleValues, @Nullable String defaultReply)
            throws PrompterException;

    /**
     * Prompts the user for a password.
     *
     * @param message the message to display

   */
  static <T extends @Nullable Object> T[] toArrayImpl(
      @Nullable Object[] src, int offset, int len, T[] dst) {
    checkPositionIndexes(offset, offset + len, src.length);
    if (dst.length < len) {
      dst = newArray(dst, len);
    } else if (dst.length > len) {
      @Nullable Object[] unsoundlyCovariantArray = dst;
      unsoundlyCovariantArray[len] = null;
    }

    public @Nullable K floorKey(K key) {
      return standardFloorKey(key);
    }

    @Override
    public @Nullable Entry<K, V> ceilingEntry(K key) {
      return standardCeilingEntry(key);
    }

    @Override
    public @Nullable K ceilingKey(K key) {
      return standardCeilingKey(key);
    }

    @Override
    public @Nullable Entry<K, V> higherEntry(K key) {
      return standardHigherEntry(key);