@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListRemoveAllTester<E> extends AbstractListTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testRemoveAll_duplicate() {
    ArrayWithDuplicate<E> arrayAndDuplicate = createArrayWithDuplicateElement();
    collection = getSubjectGenerator().create(arrayAndDuplicate.elements);

  public int hashCode() {
    return presentFeatures.hashCode() * 31 + absentFeatures.hashCode();
  }

  @Override
  public String toString() {
    return "{TesterRequirements: present=" + presentFeatures + ", absent=" + absentFeatures + "}";
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

   * opening the data stream.
   *
   * <p>The default implementation returns {@link Optional#absent}. Some sources, such as a {@code
   * CharSequence}, may return a non-absent value. Note that in such cases, it is <i>possible</i>
   * that this method will return a different number of chars than would be returned by reading all
   * of the chars.
   *

   * opening the data stream.
   *
   * <p>The default implementation returns {@link Optional#absent}. Some sources, such as a {@code
   * CharSequence}, may return a non-absent value. Note that in such cases, it is <i>possible</i>
   * that this method will return a different number of chars than would be returned by reading all
   * of the chars.
   *

  public void testPollFirst() {
    assertEquals(a, navigableSet.pollFirst());
    assertEquals(values.subList(1, values.size()), copyToList(navigableSet));
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testPollFirstUnsupported() {
    assertThrows(UnsupportedOperationException.class, () -> navigableSet.pollFirst());
  }

  @CollectionSize.Require(SEVERAL)

    return implied;
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Inherited
  @TesterAnnotation
  public @interface Require {
    SetFeature[] value() default {};

    SetFeature[] absent() default {};
  }

    return implied;
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Inherited
  @TesterAnnotation
  public @interface Require {
    MultimapFeature[] value() default {};

    MultimapFeature[] absent() default {};
  }

    return implied;
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Inherited
  @TesterAnnotation
  public @interface Require {
    ListFeature[] value() default {};

    ListFeature[] absent() default {};
  }

  @CollectionSize.Require(ZERO)
  public void testIsEmpty_yes() {
    assertTrue("isEmpty() should return true", collection.isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testIsEmpty_no() {
    assertFalse("isEmpty() should return false", collection.isEmpty());
  }

  /*
   * We're not really testing the implementation of Stream, only that we're getting a Stream
   * that corresponds to the expected elements.
   */

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testStreamToArrayUnknownOrder() {
    Helpers.assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)