* <p><b>Note:</b> if elements are non-null and won't be added or removed after this point, use
   * {@link ImmutableSet#of()} or {@link ImmutableSet#copyOf(Object[])} instead. If {@code E} is an
   * {@link Enum} type, use {@link EnumSet#of(Enum, Enum[])} instead. Otherwise, strongly consider
   * using a {@code LinkedHashSet} instead, at the cost of increased memory footprint, to get
   * deterministic iteration behavior.
   *

                case ScriptType.INIT:
                    return "gradle/my.init"
            }
        }
    }

    enum ScriptDiscovery {
        DEFAULT,
        APPLIED
    }

    enum ScriptLanguage {
        GROOVY,
        KOTLIN
    }

    enum ScriptType {
        PROJECT,
        SETTINGS,
        INIT,
        BUILDSRC_PROJECT,
        BUILDSRC_SETTINGS,
    }

   * with an implementation specialized for enums. Unlike {@link ImmutableSet#toImmutableSet}, the
   * resulting set will iterate over elements in their enum definition order, not encounter order.
   *
   * @since 21.0
   */
  public static <E extends Enum<E>> Collector<E, ?, ImmutableSet<E>> toImmutableEnumSet() {
    return CollectCollectors.toImmutableEnumSet();
  }

from collections import deque
from dataclasses import dataclass
from datetime import datetime, timezone
from decimal import Decimal
from enum import Enum
from pathlib import PurePath, PurePosixPath, PureWindowsPath
from typing import Optional

import pytest
from fastapi._compat import PYDANTIC_V2, Undefined
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel, Field, ValidationError

    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/dataClasses.kt");
  }

  @Test
  @TestMetadata("enums.kt")
  public void testEnums() {
    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/enums.kt");
  }

  @Test
  @TestMetadata("simple.kt")
  public void testSimple() {

    RulesModeInternal getConfiguredRulesMode();

    @Override
    Property<String> getDefaultProjectsExtensionName();

    List<VersionCatalogBuilder> getDependenciesModelBuilders();

    enum RepositoriesModeInternal {
        PREFER_PROJECT(true),
        PREFER_SETTINGS(false),
        FAIL_ON_PROJECT_REPOS(false);

        private final boolean useProjectRepositories;

 * limitations under the License.
 */

package org.gradle.internal.component.external.model.maven;

/**
 * The context for a dependency parsed from a Maven POM. Note that the order of this enum is important for the module metadata cache.
 */
public enum MavenDependencyType {
    DEPENDENCY(false),
    RELOCATION(false),
    OPTIONAL_DEPENDENCY(true),
    DEPENDENCY_MANAGEMENT(true);

    public final boolean optional;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.external.javadoc;

/**
 * This enum maps to the -public, -protected, -package and -private options of the javadoc executable.
 */
public enum JavadocMemberLevel {
    /**
     * Shows only public classes and members.
     */
    PUBLIC,
    /**

 * limitations under the License.
 */

package org.gradle.internal.component.external.descriptor;

/**
 * A "scope" taken from a Maven POM. Note that the order of this enum is important for the module metadata cache.
 */
public enum MavenScope {
    Compile("compile"),
    Runtime("runtime"),
    Provided("provided"),
    Test("test"),
    System("system");

    private final String lowerName;

        logging.events == [] as Set
        logging.minGranularity == -1
        logging.maxGranularity == -1
        logging.stackTraceFilters == [TRUNCATE] as Set
    }

    def "allows events to be added as enum values"() {
        when:
        logging.events STARTED, SKIPPED

        then:
        logging.events == [STARTED, SKIPPED] as Set
    }

    def "allows events to be added as string values"() {
        when: