* AbstractSet#iterator()}.
 */
abstract class IncidentEdgeSet<N> extends AbstractSet<EndpointPair<N>> {
  final N node;
  final ArchetypeGraph<N> graph;
  final EdgeType edgeType;

  enum EdgeType {
    INCOMING, // incoming incident edges only
    OUTGOING, // outgoing incident edges only
    BOTH // both incoming and outgoing incident edges
  }

        }
    }

    @SuppressWarnings("unchecked")
    private static <T extends Enum<T>> Object getSessionKeyInquireType(Class<?> inquireTypeClass) {
        return Enum.valueOf((Class<T>) inquireTypeClass, "KRB5_GET_SESSION_KEY");
    }

    /** Path prefix for API endpoints. */
    protected String pathPrefix;

    /**
     * Enumeration of supported API format types.
     */
    protected enum FormatType {
        /** Search API format. */
        SEARCH,
        /** Label API format. */
        LABEL,
        /** Popular word API format. */
        POPULARWORD,
        /** Favorite API format. */

              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());
    }
  }

  private enum PlatformSpecificExceptionBatch {
    PLATFORM {
      @GwtIncompatible
      @J2ktIncompatible
      @Override
      // returns the types available in "normal" environments

  static final String ERROR_ELEMENT_REMOVED = "used to generate this set";
  private static final String NODE_STRING = "Node";
  private static final String EDGE_STRING = "Edge";

  enum EdgeType {
    UNDIRECTED,
    DIRECTED;
  }

  private TestUtil() {}

  static void assertNodeNotInGraphErrorMessage(Throwable throwable) {
    assertThat(throwable).hasMessageThat().startsWith(NODE_STRING);

  static final String ENDPOINTS_MISMATCH =
      "Mismatch: endpoints' ordering is not compatible with directionality of the graph";

  /** Singleton edge value for {@link Graph} implementations backed by {@link ValueGraph}s. */
  enum Presence {
    EDGE_EXISTS
  }

   * <p>The ordering of the {@link State} enum is defined such that if there is a state transition
   * from {@code A -> B} then {@code A.compareTo(B) < 0}. N.B. The converse is not true, i.e. if
   * {@code A.compareTo(B) < 0} then there is <b>not</b> guaranteed to be a valid state transition
   * {@code A -> B}.
   *
   * @since 9.0 (in 1.0 as {@code com.google.common.base.Service.State})
   */
  enum State {

 * - Quota exceeded
 */
public class SmbResourceException extends SmbException {

    private static final long serialVersionUID = 1L;

    /**
     * Resource type that caused the error
     */
    public enum ResourceType {
        FILE_HANDLE, CONNECTION, MEMORY, DISK_SPACE, QUOTA, LOCK, BUFFER, THREAD_POOL
    }

    private final ResourceType resourceType;
    private final long availableResources;

      events += "plan $id cancel"
      canceled = true
    }

    override fun retry(): FakePlan? {
      check(!retryTaken)
      retryTaken = true
      return retry
    }
  }

  enum class ConnectState {
    READY,
    TCP_CONNECTED,
    TLS_CONNECTED,
  }

 * *protocol* to identify how HTTP messages are framed.
 *
 * [ietf_alpn]: http://tools.ietf.org/html/draft-ietf-tls-applayerprotoneg
 */
enum class Protocol(
  private val protocol: String,
) {
  /**
   * An obsolete plaintext framing that does not use persistent sockets by default.
   */
  HTTP_1_0("http/1.0"),

  /**