// each feature gate when no feature gates are specified.
func TestEnabledDefaults(t *testing.T) {
	for featureName, feature := range InitFeatureGates {
		featureList := make(map[string]bool)

		enabled := Enabled(featureList, featureName)
		if enabled != feature.Default {
			t.Errorf("Enabled returned %v instead of default value %v for feature %s", enabled, feature.Default, featureName)
		}
	}
}

import java.lang.reflect.Field
import java.util.concurrent.atomic.AtomicBoolean

class ToBeFixedSpecInterceptor {

    private final String feature

    ToBeFixedSpecInterceptor(String feature) {
        this.feature = feature
    }

    void intercept(SpecElementInfo specElementInfo, String[] iterationMatchers) {
        if (specElementInfo instanceof SpecInfo) {

		// we have to parse this from KnownFeatures, because usage of mutable FeatureGate is not allowed in unit tests
		feature := featureGateRegex.FindString(featureText)
		if strings.Contains(featureText, string(featuregate.Alpha)) && feature != "AllAlpha" {
			alphaFeatures.Insert(feature)
		}

	}

	for name, controller := range NewControllerDescriptors() {
		if len(controller.GetAliases()) == 0 {
			continue

		logger.Info("Skip registration of plugin since feature flag is enabled", "plugin", inTreePluginName, "feature", pluginInfo.pluginUnregisterFeature)
		return plugins, nil
	}
	plugins = append(plugins, pluginInfo.pluginProbeFunction()...)
	return plugins, nil
}

type pluginInfo struct {
	pluginMigrationFeature  featuregate.Feature
	pluginUnregisterFeature featuregate.Feature
	pluginProbeFunction     probeFn
}

                    capability('org', 'feature-1', '1.0')
                    attribute('org.gradle.usage', 'java-runtime')
                    attribute('org.gradle.libraryelements', 'jar')
                    attribute('org.gradle.category', 'library')
                    artifact('feat1')
                }
                variant('feature2') {
                    capability('org', 'feature-2', '1.0')

import org.gradle.api.provider.Provider;

/**
 * Status of a feature in a build that affects Gradle behavior,
 * and may impose additional requirements on plugins or build scripts.
 * <p>
 * It is possible to check if the feature is {@link #getActive() active} in the current build.
 * The {@link #getRequested() requested} property shows whether the user opted in or opted out from the feature.
 *
 * @see BuildFeatures
 * @since 8.5
 */

            component.getFeatures().add(feature);

            component.addVariantsFromConfiguration(feature.getApiElementsConfiguration(), new JavaConfigurationVariantMapping("compile", true, feature.getCompileClasspathConfiguration()));
            component.addVariantsFromConfiguration(feature.getRuntimeElementsConfiguration(), new JavaConfigurationVariantMapping("runtime", true, feature.getRuntimeClasspathConfiguration()));

tasks.register("checkFeatures") {
    group = "verification"
    description = "Run all feature tests"
    dependsOn(gradle.includedBuild("admin-feature").task(":config:check"))
    dependsOn(gradle.includedBuild("user-feature").task(":data:check"))
    dependsOn(gradle.includedBuild("user-feature").task(":table:check"))

name: Feature Enhancement Request
description: I want to make an existing feature better
labels: ["type=enhancement"]
body:
  - type: markdown
    attributes:
      value: >
        Filing feature requests is one of the most popular ways to contribute to Guava.


        Be aware, though: most feature requests are not accepted, even if they're suggested by
        a full-time Guava team member. [Feedback](https://stackoverflow.com/a/4543114) from our

    void visitFeatureAnnotation(ToBeFixedForConfigurationCache annotation, FeatureInfo feature) {

        if (GradleContextualExecuter.isNotConfigCache()) {
            return
        }

        if (!isEnabledSpec(annotation, feature)) {
            return
        }

        if (annotation.skip() != DO_NOT_SKIP) {
            feature.skipped = true
            return
        }