sid_t *sid;
	} LsarDomainInfo;

	typedef struct {
		unicode_string name;
		unicode_string dns_domain;
		unicode_string dns_forest;
		uuid_t domain_guid;
		sid_t *sid;
	} LsarDnsDomainInfo;

	enum {
		POLICY_INFO_AUDIT_EVENTS   = 2,
		POLICY_INFO_PRIMARY_DOMAIN = 3,
		POLICY_INFO_ACCOUNT_DOMAIN = 5,
		POLICY_INFO_SERVER_ROLE    = 6,
		POLICY_INFO_MODIFICATION   = 9,
		POLICY_INFO_DNS_DOMAIN     = 12
	};

     */
    static GetCheckedTypeValidator getBestValidator() {
      try {
        @SuppressWarnings("rawtypes") // class literals
        Class<? extends Enum> theClass =
            Class.forName(CLASS_VALUE_VALIDATOR_NAME).asSubclass(Enum.class);
        return (GetCheckedTypeValidator) theClass.getEnumConstants()[0];
      } catch (ClassNotFoundException
          | RuntimeException

                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Enumeration of supported protocol types for URI validation.
     */
    public enum ProtocolType {
        /**
         * Web protocols (http, https, etc.).
         */
        WEB,
        /**
         * File protocols (file, etc.).
         */
        FILE;
    }

        if (StringUtil.isNotBlank(scriptType)) {
            return scriptType;
        }
        return Constants.DEFAULT_SCRIPT;
    }

    public enum ConfigType {
        WEB("W"), FILE("F"), DATA("D");

        private final String typePrefix;

        ConfigType(final String typePrefix) {
            this.typePrefix = typePrefix;
        }

    final Optional<BinaryNode> right;

    BinaryNode(int x, Optional<BinaryNode> left, Optional<BinaryNode> right) {
      this.x = x;
      this.left = left;
      this.right = right;
    }
  }

  enum Topology {
    BALANCED {
      @Override
      Optional<BinaryNode> createTree(int size, Random rng) {
        if (size == 0) {
          return Optional.absent();
        } else {

/**
 * Utility class for converting between various ASCII case formats. Behavior is undefined for
 * non-ASCII input.
 *
 * @author Mike Bostock
 * @since 1.0
 */
@GwtCompatible
public enum CaseFormat {
  /**
   * Hyphenated variable naming convention, e.g., "lower-hyphen". This format is also colloquially
   * known as "kebab case".
   */
  LOWER_HYPHEN(CharMatcher.is('-'), "-") {
    @Override

import java.util.concurrent.Executor;
import org.jspecify.annotations.NullUnmarked;

/** Measures the size of AbstractFuture implementations. */
@NullUnmarked
public class AbstractFutureFootprintBenchmark {

  enum State {
    NOT_DONE,
    FINISHED,
    CANCELLED,
    FAILED
  }

  @Param State state;
  @Param Impl impl;

  @Param({"0", "1", "5", "10"})
  int numListeners;

  @Param({"0", "1", "5", "10"})

/**
 * Optional features of classes derived from {@code Map}.
 *
 * @author George van den Driessche
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum MapFeature implements Feature<Map> {
  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code containsKey(null)},
   * {@code get(null)}, {@code keySet().contains(null)} or {@code remove(null)}.
   */

    @EnumSource(RequestParam.class)
    @DisplayName("send handles each RequestParam enum constant")
    void send_eachRequestParam_isAccepted(RequestParam param) throws Exception {
        // Arrange: stub per-call return to ensure interaction with the exact enum
        when(tree.send(eq(request), eq(param))).thenReturn(response);

        // Act

package com.google.common.io;

import org.jspecify.annotations.NullUnmarked;

/**
 * Options controlling the behavior of sources/sinks/streams for testing.
 *
 * @author Colin Decker
 */
@NullUnmarked
public enum TestOption {
  OPEN_THROWS,
  SKIP_THROWS,
  READ_THROWS,
  WRITE_THROWS,
  CLOSE_THROWS,
  AVAILABLE_ALWAYS_ZERO