for (int i = 0; i < getNumElements(); i++) {
      assertTrue(
          "toArray(overSizedE[]) should contain element " + expectedSubArray[i],
          subArray.contains(expectedSubArray[i]));
    }
    assertNull(
        "The array element immediately following the end of the collection should be nulled",
        array[getNumElements()]);

    switch (elements.length) {
      case 0:
        return of();
      case 1:
        @SuppressWarnings("unchecked") // safe because it came from `collection`
        E element = (E) elements[0];
        return of(element);
      default:
        return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(elements));
    }
  }

    }

    @Test
    @DisplayName("Test nextElement() returns transaction on first call")
    void testNextElementFirstCall() {
        Object element = transaction.nextElement();
        assertSame(transaction, element, "First nextElement should return the transaction itself");
    }

    @Test
    @DisplayName("Test nextElement() changes command on second call")

package org.apache.maven.cling.invoker.mvnup.goals;

import java.nio.file.Path;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import eu.maveniverse.domtrip.Document;
import eu.maveniverse.domtrip.Element;
import eu.maveniverse.domtrip.maven.Coordinates;
import eu.maveniverse.domtrip.maven.MavenPomElements;
import org.apache.maven.api.cli.mvnup.UpgradeOptions;
import org.apache.maven.cling.invoker.mvnup.UpgradeContext;

 */
package jcifs.internal.smb2.lock;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lock data structure.
 *
 * This class represents a single lock element used in
 * SMB2 Lock requests for byte-range locking.
 *
 * @author mbechler
 */
public class Smb2Lock implements Encodable {

    /**
     * Flag indicating a shared lock that allows concurrent read access.

    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterator));
    assertThat(expected).hasMessageThat().isEqualTo("expected one element but was: <one, two>");
  }

  public void testGetOnlyElement_noDefault_fiveElements() {
    Iterator<String> iterator = asList("one", "two", "three", "four", "five").iterator();
    IllegalArgumentException expected =

    public E last() {
      SortedSet<E> sortedUnfiltered = (SortedSet<E>) unfiltered;
      while (true) {
        E element = sortedUnfiltered.last();
        if (predicate.apply(element)) {
          return element;
        }
        sortedUnfiltered = sortedUnfiltered.headSet(element);
      }
    }
  }

  @GwtIncompatible // NavigableSet

        final StringBuilder sb = new StringBuilder();
        for (final CharSequence element : elements) {
            if (sb.length() > 0) {
                if (delimiter != null) {
                    sb.append(delimiter);
                } else {
                    sb.append("null");
                }
            }
            sb.append(element);
        }
        return sb.toString();
    }

import java.util.NoSuchElementException;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * An {@link Iterator} that returns a single value.
 *
 * @author koichik
 * @param <E> the element type
 */
public class SingleValueIterator<E> implements Iterator<E> {

    /** The only value returned by the iterator. */
    protected final E value;

    /** {@literal true} if the iterator has more elements. */

    /**
     * This default mode for combining a DOM node during merge means that where element names match, the process will
     * try to merge the element attributes and values, rather than overriding the recessive element completely with the
     * dominant one. This means that wherever the dominant element doesn't provide the value or a particular attribute,
     * that value or attribute will be set from the recessive DOM node.