@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultisetAddTester<E> extends AbstractMultisetTester<E> {
  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  public void testAddUnsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getMultiset().add(e0()));
  }

  @CollectionFeature.Require(SUPPORTS_ADD)

  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)

  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testElementSetReflectsRemove() {
    Set<E> elementSet = getMultiset().elementSet();
    assertTrue(elementSet.contains(e0()));
    getMultiset().removeAll(singleton(e0()));
    assertFalse(elementSet.contains(e0()));
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_REMOVE)

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class SetRemoveTester<E> extends AbstractSetTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class SetRemoveTester<E> extends AbstractSetTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

        com.google.common.base.Optional.absent(),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    assertEquals(
        com.google.common.base.Optional.of("2"),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    // Test that the first generated instance for different cgcb.Optional<T> is always absent().

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@IgnoreJRERequirement // We opt into library desugaring for our tests.
public class CollectionForEachTester<E> extends AbstractCollectionTester<E> {
  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    Helpers.assertEqualIgnoringOrder(asList(createSamplesArray()), elements);
  }

  public void testToArray_noArg() {
    Object[] actual = getList().toArray();
    assertArrayEquals("toArray() order should match list", createOrderedArray(), actual);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }

  public void testOffer_nullSupported() {
    assertTrue("offer(null) should return true", getQueue().offer(null));
    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testOffer_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> getQueue().offer(null));
    expectUnchanged();

  val tag: Long,
  /** Encode and decode the value once tags are handled. */
  private val codec: Codec<T>,
  /** True if the default value should be used if this value is absent during decoding. */
  val isOptional: Boolean = false,
  /** The value to return if this value is absent. Undefined unless this is optional. */
  val defaultValue: T? = null,
  /** True to set the encoded or decoded value as the type hint for the current SEQUENCE. */