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());
  }

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

  @CollectionFeature.Require({KNOWN_ORDER, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testRemove_sizeMany() {
    assertEquals("sizeManyQueue.remove() should return first element", e0(), getQueue().remove());
    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

      long tmp = array[i];
      array[i] = array[j];
      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance
   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Longs.asList(array),

  private M multimap;

  protected M multimap() {
    return multimap;
  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];

      return ImmutableSet.copyOf(elements);
    }
  }

  public static class DegeneratedImmutableSetGenerator extends TestStringSetGenerator {
    @SuppressWarnings("DistinctVarargsChecker") // deliberately testing deduplication
    @Override
    protected Set<String> create(String[] elements) {
      return ImmutableSet.of(elements[0], elements[0]);
    }
  }

      char tmp = array[i];
      array[i] = array[j];
      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance
   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Chars.asList(array),

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

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

    return new Strings();
  }

  @Override
  public Multiset<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Multiset<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];

        }
        foundTrustedCertificate = true
        continue
      }

      // Search for the certificate in the chain that signed this certificate. This is typically
      // the next element in the chain, but it could be any element.
      val i = queue.iterator()
      while (i.hasNext()) {
        val signingCert = i.next() as X509Certificate
        if (verifySignature(toVerify, signingCert, result.size - 1)) {