this.element = checkNotNull(element);
  }

  @Override
  public E get(int index) {
    Preconditions.checkElementIndex(index, 1);
    return element;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return singletonIterator(element);
  }

  @Override
  public Spliterator<E> spliterator() {
    return singleton(element).spliterator();
  }

  @Override
  public int size() {
    return 1;

 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A generator that relies on a preexisting generator for most of its work. For example, a derived
 * iterator generator may delegate the work of creating the underlying collection to an inner
 * collection generator.
 *
 * <p>{@code GwtTestSuiteGenerator} expects every {@code DerivedIterator} implementation to provide

 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A generator that relies on a preexisting generator for most of its work. For example, a derived
 * iterator generator may delegate the work of creating the underlying collection to an inner
 * collection generator.
 *
 * <p>{@code GwtTestSuiteGenerator} expects every {@code DerivedIterator} implementation to provide

    assertFalse(list.contains("chicken"));
    assertEquals(-1, list.indexOf("chicken"));
    assertEquals(-1, list.lastIndexOf("chicken"));
  }

  private static <E> Iterator<E> asIterator(E... elements) {
    return asList(elements).iterator();
  }

  // In GWT, java.util.TreeSet throws ClassCastException when the comparator
  // throws it, unlike the JDK.  Therefore, we accept ClassCastException as a

) : Cloneable {
  val headersList: List<Header>
    get() {
      val result = mutableListOf<Header>()
      for (inputHeader in headers) {
        val (key, value) = inputHeader.entries.iterator().next()
        result.add(Header(key, value))
      }
      return result
    }

  public override fun clone() = Case(seqno, this.wire, headers)

   * #expectContents(Object[]) expectContents(E...)} and other convenience methods. The creation of
   * multiple containers in a single method is discouraged in most cases, but it is vital to the
   * iterator tests.
   *
   * @return the new container instance
   * @param newValue the new container instance
   */
  @CanIgnoreReturnValue
  protected C resetContainer(C newValue) {
    container = newValue;

 * a single section.
 */
internal fun withoutSectionSpans(mappings: List<Mapping>): List<Mapping> {
  val result = mutableListOf<Mapping>()

  val i = mappings.iterator()
  var current = i.next()

  while (true) {
    if (current.spansSections) {
      result +=
        Mapping(
          current.sourceCodePoint0,
          current.section + 0x7f,

            return parent.isEmpty();
        }

        public boolean contains(final Object o) {
            return parent.contains(o);
        }

        public Iterator<E> iterator() {
            return parent.iterator();
        }

        public Object[] toArray() {
            return parent.toArray();
        }

        public <T> T[] toArray(final T[] a) {

  }

  /**
   * Returns statistics over a dataset containing the given values. The iterator will be completely
   * consumed by this method.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision)
   */
  public static Stats of(Iterator<? extends Number> values) {
    StatsAccumulator accumulator = new StatsAccumulator();

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.DoNotCall;
import java.util.ListIterator;
import org.jspecify.annotations.Nullable;

/**
 * A list iterator that does not support {@link #remove}, {@link #add}, or {@link #set}.
 *
 * @since 7.0
 * @author Louis Wasserman
 */
@GwtCompatible
public abstract class UnmodifiableListIterator<E extends @Nullable Object>