}

  @Override
  public <E extends T> E min(Iterator<E> iterator) {
    return forwardOrder.max(iterator);
  }

  @Override
  public <E extends T> E min(Iterable<E> iterable) {
    return forwardOrder.max(iterable);
  }

  @Override
  public <E extends T> E max(@ParametricNullness E a, @ParametricNullness E b) {
    return forwardOrder.min(a, b);
  }

  @Override

  protected ListIteratorTester(
      int steps,
      Iterable<E> elementsToInsert,
      Iterable<? extends IteratorFeature> features,
      Iterable<E> expectedElements,
      int startIndex) {
    super(steps, elementsToInsert, features, expectedElements, KnownOrder.KNOWN_ORDER, startIndex);
  }

  @Override
  protected final Iterable<? extends Stimulus<E, ? super ListIterator<E>>> getStimulusValues() {

import jetbrains.buildServer.configs.kotlin.DslContext
import model.CIBuildModel

class PartialTrigger<T : BaseGradleBuildType>(
    triggerName: String,
    triggerId: String,
    model: CIBuildModel,
    dependencies: Iterable<T>,
) : BaseGradleBuildType(init = {
        id("${model.projectId}_${triggerId}_Trigger")
        uuid = "${DslContext.uuidPrefix}_${model.projectId}_${triggerId}_Trigger"
        name = "$triggerName (Trigger)"

    return new ArrayDeque<>();
  }

  /**
   * Creates an {@code ArrayDeque} containing the elements of the specified iterable, in the order
   * they are returned by the iterable's iterator.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> elements) {
    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }

import java.util.Iterator;

/**
 * Adapts a test iterable generator to give a TestIteratorGenerator.
 *
 * @author George van den Driessche
 */
@GwtCompatible
public final class DerivedTestIteratorGenerator<E>
    implements TestIteratorGenerator<E>, DerivedGenerator {
  private final TestSubjectGenerator<? extends Iterable<E>> collectionGenerator;

  public DerivedTestIteratorGenerator(

    Iterable<Long> iterable = iterable(Collections.<Long>emptySet());
    assertThat(ImmutableLongArray.copyOf(iterable)).isSameInstanceAs(ImmutableLongArray.of());
  }

  public void testCopyOf_iterable_notCollection_nonempty() {
    List<Long> list = Arrays.asList(0L, 1L, 3L);
    ImmutableLongArray iia = ImmutableLongArray.copyOf(iterable(list));
    list.set(2, 2L);

    multimap().putAll(k0(), Collections.emptyList());
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllOnlyCallsIteratorOnce() {
    Iterable<V> iterable =
        new Iterable<V>() {
          private boolean calledIteratorAlready = false;

          @Override
          public Iterator<V> iterator() {
            checkState(!calledIteratorAlready);

            parameters["file"] as File,
            parameters["gradleJars"] as Iterable<File>,
            parameters["pluginDependenciesSpecQualifiedName"] as String,
            parameters["pluginDependencySpecQualifiedName"] as String,
        )
    }
}


fun writeBuiltinPluginIdExtensionsTo(
    file: File,
    gradleJars: Iterable<File>,
    pluginDependenciesSpecQualifiedName: String,

  }

  private static class CountingIterable implements Iterable<String> {
    int count = 0;

    @Override
    public Iterator<String> iterator() {
      count++;
      return Iterators.forArray("a", "b", "a");
    }
  }

  public void testCopyOf_plainIterable() {
    CountingIterable iterable = new CountingIterable();
    Set<String> set = copyOf(iterable);
    assertEquals(2, set.size());

   *     original iterable.
   * @throws NullPointerException if the specified iterable is null or has any null elements.
   * @since 12.0
   */
  public static <E extends Comparable<? super E>> Collection<List<E>> orderedPermutations(
      Iterable<E> elements) {
    return orderedPermutations(elements, Ordering.natural());
  }

  /**
   * Returns a {@link Collection} of all the permutations of the specified {@link Iterable} using