* {@code ImmutableList}, use {@code stream.sorted().collect(toImmutableList())}.
   *
   * @throws NullPointerException if any element in the input is null
   * @since 21.0
   */
  public static <E extends Comparable<? super E>> ImmutableList<E> sortedCopyOf(
      Iterable<? extends E> elements) {
    Comparable<?>[] array = Iterables.toArray(elements, new Comparable<?>[0]);
    checkElementsNotNull((Object[]) array);
    Arrays.sort(array);

   */

  ANY(ZERO, ONE, SEVERAL);

  private final Set<Feature<? super Collection>> implied;
  private final @Nullable Integer numElements;

  CollectionSize(int numElements) {
    this.implied = emptySet();
    this.numElements = numElements;
  }

  CollectionSize(Feature<? super Collection>... implied) {
    // Keep the order here, so that PerCollectionSizeTestSuiteBuilder

    implements SortedMultiset<E> {
  abstract SortedMultiset<E> forwardMultiset();

  @Nullable private transient Comparator<? super E> comparator;

  @Override
  public Comparator<? super E> comparator() {
    Comparator<? super E> result = comparator;
    if (result == null) {
      return comparator = Ordering.from(forwardMultiset().comparator()).reverse();
    }
    return result;
  }

   */

  ANY(ZERO, ONE, SEVERAL);

  private final Set<Feature<? super Collection>> implied;
  private final @Nullable Integer numElements;

  CollectionSize(int numElements) {
    this.implied = emptySet();
    this.numElements = numElements;
  }

  CollectionSize(Feature<? super Collection>... implied) {
    // Keep the order here, so that PerCollectionSizeTestSuiteBuilder

      Class<? super @NonNull E> type, E... contents) {
    return new MinimalCollection<>(type, true, contents);
  }

  private final E[] contents;
  private final Class<? super @NonNull E> type;
  private final boolean allowNulls;

  // Package-private so that it can be extended.
  MinimalCollection(Class<? super @NonNull E> type, boolean allowNulls, E... contents) {

     */
    public ClIndexOutOfBoundsException() {
        super();
    }

    /**
     * Creates a {@link ClIndexOutOfBoundsException}.
     *
     * @param message
     *            Message
     */
    public ClIndexOutOfBoundsException(final String message) {
        super(message);
    }

        super(config, SMB_COM_CLOSE);
        this.fid = fid;
        this.lastWriteTime = lastWriteTime;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#getResponse()
     */
    @Override
    public final SmbComBlankResponse getResponse() {
        return (SmbComBlankResponse) super.getResponse();
    }

    /**

 * @param <E> Edge parameter type
 */
final class UndirectedMultiNetworkConnections<N, E>
    extends AbstractUndirectedNetworkConnections<N, E> {

  private UndirectedMultiNetworkConnections(Map<E, N> incidentEdges) {
    super(incidentEdges);
  }

  static <N, E> UndirectedMultiNetworkConnections<N, E> of() {
    return new UndirectedMultiNetworkConnections<>(
        new HashMap<E, N>(INNER_CAPACITY, INNER_LOAD_FACTOR));
  }

  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public Comparator<? super K> comparator() {
    Comparator<? super K> comparator = delegate.comparator();
    if (comparator == null) {
      comparator = (Comparator<? super K>) NATURAL_ORDER;
    }
    return comparator;
  }

  @Override
  public boolean containsKey(Object key) {
    try {

            .resolveType(t));
    assertEquals(
        String.class,
        new TypeResolver()
            .where(
                new TypeCapture<List<? super T>>() {}.capture(),
                new TypeCapture<List<? super String>>() {}.capture())
            .resolveType(t));
  }

  public <T> void testWhere_incompatibleGenericArrayMapping() {
    assertThrows(
        IllegalArgumentException.class,