/** Utility methods used in various common.graph tests. */
@NullUnmarked
final class TestUtil {
  static final String ERROR_ELEMENT_NOT_IN_GRAPH = "not an element of this graph";
  static final String ERROR_NODE_NOT_IN_GRAPH =
      "Should not be allowed to pass a node that is not an element of the graph.";
  static final String ERROR_ELEMENT_REMOVED = "used to generate this set";
  private static final String NODE_STRING = "Node";

        assertTrue(itr.hasNext(), "Should have first element ready");
        SmbResource r1 = itr.next();
        assertNotNull(r1, "First adapted resource must not be null");
        // For workgroup/server entries, names end with '/'
        assertTrue(r1.getName().endsWith("/"), "Name should end with '/'");

        assertTrue(itr.hasNext(), "Should have second element ready");
        SmbResource r2 = itr.next();

    List<Object> list = new ArrayList<>(equalityGroup.length);
    for (int i = 0; i < equalityGroup.length; i++) {
      Object element = equalityGroup[i];
      if (element == null) {
        throw new NullPointerException("at index " + i);
      }
      list.add(element);
    }
    equalityGroups.add(list);
    return this;
  }

  /** Run tests on equals method, throwing a failure on an invalid test */

   * extends AbstractListTester.) We could also iterate over all elements to
   * verify absence
   */
  protected void expectMissing(E... elements) {
    for (E element : elements) {
      assertFalse("Should not contain " + element, actualContents().contains(element));
    }
  }

  protected E[] createSamplesArray() {
    E[] array = getSubjectGenerator().createArray(getNumElements());
    getSampleElements().toArray(array);

   * #successors(Object)} and {@link #incidentEdges(Object)}.
   *
   * @since 29.0
   */
  @Override
  ElementOrder<N> incidentEdgeOrder();

  //
  // Element-level accessors
  //

  /**
   * Returns a live view of the nodes which have an incident edge in common with {@code node} in
   * this graph.
   *

 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * @author wyukawa
 * @param <T> the element type
 * @see Indexed
 */
public class IndexedIterator<T> implements Iterator<Indexed<T>> {

    /** {@link Iterator} */
    protected final Iterator<T> iterator;

    /** The index of the iterator. */

   *
   * @throws IllegalArgumentException if {@code node} is not an element of this network
   */
  @Override
  int outDegree(N node);

  /**
   * Returns the nodes which are the endpoints of {@code edge} in this network.
   *
   * @throws IllegalArgumentException if {@code edge} is not an element of this network
   */
  EndpointPair<N> incidentNodes(E edge);

  /**

        return@binarySearch target.compareTo(b0b1)
      }

    return when {
      offset >= 0 -> offset * 4 // This section was found by binary search.
      else -> (-offset - 2) * 4 // Not found? Use the preceding element.
    }
  }

  /**
   * Binary search [ranges] for [codePoint], looking at its bottom 7 bits.
   *
   * This binary searches over 4-byte entries, and so it needs to adjust binary search indices

      if (exception == null) {
        exception = ioe
      }
    }
  }
  if (exception != null) {
    throw exception
  }
}

internal fun <E> MutableList<E>.addIfAbsent(element: E) {
  if (!contains(element)) add(element)
}

internal fun Exception.withSuppressed(suppressed: List<Exception>): Throwable =
  apply {
    for (e in suppressed) addSuppressed(e)
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListHashCodeTester<E> extends AbstractListTester<E> {
  public void testHashCode() {
    int expectedHashCode = 1;
    for (E element : getOrderedElements()) {
      expectedHashCode = 31 * expectedHashCode + ((element == null) ? 0 : element.hashCode());
    }
    assertEquals(
        "A List's hashCode() should be computed from those of its elements.",
        expectedHashCode,