public void testPoll_size1() {
    assertEquals("size1Queue.poll() should return first element", e0(), getQueue().poll());
    expectMissing(e0());
  }

  @CollectionFeature.Require({KNOWN_ORDER, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testPoll_sizeMany() {
    assertEquals("sizeManyQueue.poll() should return first element", e0(), getQueue().poll());
    expectMissing(e0());
  }

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The annotated element must not be null.
 * <p>
 * Annotated fields must not be null after construction has completed.
 * <p>
 * When this annotation is applied to a method it applies to the method return value.
 *
 * @see Nullable

  DescendingImmutableSortedMultiset(ImmutableSortedMultiset<E> forward) {
    this.forward = forward;
  }

  @Override
  public int count(@Nullable Object element) {
    return forward.count(element);
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forward.firstEntry();

  public void testSubList_ofSubListNonEmpty() {
    List<E> subList = getList().subList(0, 2).subList(1, 2);
    assertEquals(
        "subList(0, 2).subList(1, 2) "
            + "should be a single-element list of the element at index 1",
        singletonList(getOrderedElements().get(1)),
        subList);
  }

  @CollectionSize.Require(absent = {ZERO})
  public void testSubList_size() {
    List<E> list = getList();

   * support concurrent multisets whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of distinct elements, the first element, its
   * count, the second element, its count, and so on.
   */
  static <E extends @Nullable Object> void writeMultiset(
      Multiset<E> multiset, ObjectOutputStream stream) throws IOException {

      Comparator<T> comparator) {
    return new LexicographicalOrdering<S>(checkNotNull(comparator));
  }

  /**
   * Returns {@code true} if each element in {@code iterable} after the first is greater than or
   * equal to the element that preceded it, according to the specified comparator. Note that this is
   * always true when the iterable has fewer than two elements.
   */

        // Test the nextElement method from Enumeration interface
        SmbComTransactionResponse element = response.nextElement();

        // Should return itself
        assertSame(response, element);

        // Can be called multiple times
        element = response.nextElement();
        assertSame(response, element);
    }

    @Test
    @DisplayName("Test with various Configuration implementations")

                return (n & 1) == 0; // isEven()
              }
            }));
    assertEquals(newArrayList("1", "3", "5"), list);
    assertFalse(
        removeIf(
            transformed,
            new Predicate<Integer>() {
              @Override
              public boolean apply(Integer n) {
                return (n & 1) == 0; // isEven()
              }
            }));

focus"},De={allowList:"object",animation:"boolean",boundary:"(string|element)",container:"(string|element|boolean)",customClass:"(string|function)",delay:"(number|object)",fallbackPlacements:"array",html:"boolean",offset:"(array|string|function)",placement:"(string|function)",popperConfig:"(null|object|function)",sanitize:"boolean",sanitizeFn:"(null|function)",selector:"(string|boolean)",template:"string",title:"(string|element|function)",trigger:"string"};class Ne extends W{constructor(t,e){if(void...

    /**
     * Gets the configuration key for the minimum size constraint.
     * @return name of size the element must be higher or equal to
     */
    String minKey() default StringUtil.EMPTY;

    /**
     * Gets the configuration key for the maximum size constraint.
     *
     * @return name of size the element must be lower or equal to
     */
    String maxKey() default StringUtil.EMPTY;