final List<Object> objectEvents = Lists.newArrayList();
    Object objCatcher =
        new Object() {
          @SuppressWarnings("unused")
          @Subscribe
          public void eat(Object food) {
            objectEvents.add(food);
          }
        };

    final List<Comparable<?>> compEvents = Lists.newArrayList();
    Object compCatcher =
        new Object() {

  }

  public void testMergeSorted_pyramid() {
    List<Iterable<Integer>> iterables = Lists.newLinkedList();
    List<Integer> allIntegers = Lists.newArrayList();

    // Creates iterators like: {{}, {0}, {0, 1}, {0, 1, 2}, ...}
    for (int i = 0; i < 10; i++) {
      List<Integer> list = Lists.newLinkedList();
      for (int j = 0; j < i; j++) {
        list.add(j);
        allIntegers.add(j);

    final List<Object> annotatedIn1Events = Lists.newArrayList();
    final List<Object> annotatedIn1And2Events = Lists.newArrayList();
    final List<Object> annotatedIn1And2AndClassEvents = Lists.newArrayList();
    final List<Object> declaredIn1AnnotatedIn2Events = Lists.newArrayList();
    final List<Object> declaredIn1AnnotatedInClassEvents = Lists.newArrayList();

  public void testPeekingIteratorBehavesLikeIteratorOnThreeElementIterable() {
    actsLikeIteratorHelper(Lists.newArrayList("A", "B", "C"));
  }

  @GwtIncompatible // works but takes 5 minutes to run
  public void testPeekingIteratorAcceptsNullElements() {
    actsLikeIteratorHelper(Lists.<@Nullable String>newArrayList(null, "A", null));
  }

  public void testPeekOnEmptyList() {

  }

  static class SubClass extends SuperClass {
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = Lists.newArrayList();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = Lists.newArrayList();

    @Override
    public void overriddenInSubclassNowhereAnnotated(Object o) {
      overriddenInSubclassNowhereAnnotatedEvents.add(o);
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect.testing.google;

import static com.google.common.collect.Lists.charactersOf;
import static java.lang.System.arraycopy;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableList;

  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment
  void setUp() {
    array = new Object[size];
    arrayList = Lists.newArrayListWithCapacity(size);
    linkedList = Lists.newLinkedList();

    for (int i = 0; i < size; i++) {
      Object value = new Object();
      array[i] = value;
      arrayList.add(value);
      linkedList.add(value);
    }
  }

    assertEquals(Lists.newArrayList("a", "b"), list);
  }

  public void testCreation_threeElements() {
    List<String> list = ImmutableList.of("a", "b", "c");
    assertEquals(Lists.newArrayList("a", "b", "c"), list);
  }

  public void testCreation_fourElements() {
    List<String> list = ImmutableList.of("a", "b", "c", "d");
    assertEquals(Lists.newArrayList("a", "b", "c", "d"), list);
  }

    assertEquals(4, (int) mmHeap.pollLast());
    mmHeap.removeAll(Lists.newArrayList(2, 3));
    assertEquals(3, mmHeap.size());
    assertTrue("Heap is not intact after removeAll()", mmHeap.isIntact());
  }

  public void testContains() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 1, 2));
    assertEquals(3, mmHeap.size());

    assertFalse(
        "Two Lists should not be equal if exactly one of them has null at a given index.",
        getList().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_shorterList() {
    Collection<E> fewerElements = getSampleElements(getNumElements() - 1);
    assertFalse(
        "Lists of different sizes should not be equal.",