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

     *
     * @return The number of {@link PropertyDesc}
     */
    int getPropertyDescSize();

    /**
     * Returns an {@link Iterable} of {@link PropertyDesc}.
     *
     * @return An {@link Iterable} of {@link PropertyDesc}
     */
    Iterable<PropertyDesc> getPropertyDescs();

    /**
     * Returns whether the {@link FieldDesc} exists.
     *
     * @param fieldName

  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() {

    throw ArrayIndexOutOfBoundsException("length=$arrayLength, offset=$offset, count=$offset")
  }
}

internal fun <T> interleave(
  a: Iterable<T>,
  b: Iterable<T>,
): List<T> {
  val ia = a.iterator()
  val ib = b.iterator()

  return buildList {
    while (ia.hasNext() || ib.hasNext()) {
      if (ia.hasNext()) {
        add(ia.next())
      }

  static final Tree h = new Tree('h', d, e, g);

  static String iterationOrder(Iterable<? extends Node> iterable) {
    StringBuilder builder = new StringBuilder();
    for (Node t : iterable) {
      builder.append(t.value);
    }
    StringBuilder forEachBuilder = new StringBuilder();
    iterable.forEach(t -> forEachBuilder.append(t.value));
    assertTrue(

    PUT_BOOLEAN() {
      @Override
      void performAction(Random random, Iterable<? extends PrimitiveSink> sinks) {
        boolean value = random.nextBoolean();
        for (PrimitiveSink sink : sinks) {
          sink.putBoolean(value);
        }
      }
    },
    PUT_BYTE() {
      @Override
      void performAction(Random random, Iterable<? extends PrimitiveSink> sinks) {
        int value = random.nextInt();

  @Override
  public <E extends Comparable<?>> E min(Iterator<E> iterator) {
    return NaturalOrdering.INSTANCE.max(iterator);
  }

  @Override
  public <E extends Comparable<?>> E min(Iterable<E> iterable) {
    return NaturalOrdering.INSTANCE.max(iterable);
  }

  @Override
  public <E extends Comparable<?>> E max(E a, E b) {
    return NaturalOrdering.INSTANCE.min(a, b);
  }

  @Override

    /**
     * Returns an {@link Iterable} that wraps an {@link Enumeration} for use in a for-each statement.
     *
     * @param <T> the element type
     * @param enumeration the enumeration (must not be {@literal null})
     * @return an {@link Iterable} wrapping the enumeration
     */
    public static <T> Iterable<T> iterable(final Enumeration<T> enumeration) {

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

  public void testCopyOf_iterable_notCollection_nonempty() {
    List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
    ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(iterable(list));
    list.set(2, 2.0);

  }

  @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