*/

package org.gradle.internal.buildoption;

import javax.annotation.Nullable;

/**
 * A feature flag. Can be enabled via the Settings object or optionally via a system property.
 */
public interface FeatureFlag extends Option {
    @Nullable
    String getSystemPropertyName();

    def "flag is disabled by default"() {
        def flag = Stub(FeatureFlag)
        flag.systemPropertyName >> null

        expect:
        !flags.isEnabled(flag)
        !flags.isEnabledWithApi(flag)
    }

    def "flag with associated system property is disabled by default"() {
        def flag = Stub(FeatureFlag)
        flag.systemPropertyName >> "prop"

        expect:

import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

public class DefaultFeatureFlags implements FeatureFlags {
    private final Set<FeatureFlag> enabled = new CopyOnWriteArraySet<FeatureFlag>();
    private final InternalOptions options;
    private final FeatureFlagListener broadcaster;

    public DefaultFeatureFlags(InternalOptions options, ListenerManager listenerManager) {

 */
@ServiceScope(Scope.BuildTree.class)
public interface FeatureFlags {
    boolean isEnabled(FeatureFlag flag);

    /**
     * Explicitly enable the given flag. The resulting flag status may still be overridden.
     */
    void enable(FeatureFlag flag);

    /**
     * Checks if the given flag was enabled with {@link #enable(FeatureFlag)}. This method doesn't take overrides into account.
     * @param flag the flag to check

import org.gradle.internal.buildoption.FeatureFlag;

import javax.annotation.Nullable;
import java.util.EnumSet;

public class FeaturePreviews {

    /**
     * Feature previews that can be turned on.
     * A feature that is no longer relevant will have the {@code active} flag set to {@code false}.
     */
    public enum Feature implements FeatureFlag {
        GROOVY_COMPILATION_AVOIDANCE(true, null),

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.BuildTree.class)
public interface FeatureFlagListener {
    void flagRead(FeatureFlag flag);

	// if the plugin unregister feature flag is set
	if featureGate.Enabled(pluginInfo.pluginUnregisterFeature) {
		klog.InfoS("Skipped registration of plugin since feature flag is enabled", "pluginName", inTreePluginName, "featureFlag", pluginInfo.pluginUnregisterFeature)
		return plugins, nil
	}

	plugins = append(plugins, pluginInfo.pluginProbeFunction()...)
	return plugins, nil
}

type pluginInfo struct {

    testImplementation(libs.kotlinCoroutines)
    testImplementation(libs.awaitility)

    integTestImplementation(project(":build-option")) {
        because("KotlinSettingsScriptIntegrationTest makes uses of FeatureFlag")
    }
    integTestImplementation(project(":language-groovy")) {
        because("ClassBytesRepositoryTest makes use of Groovydoc task.")
    }
    integTestImplementation(project(":internal-testing"))

import org.gradle.internal.cc.base.services.ConfigurationCacheEnvironmentChangeTracker
import org.gradle.groovy.scripts.ScriptSource
import org.gradle.groovy.scripts.internal.ScriptSourceListener
import org.gradle.internal.buildoption.FeatureFlag
import org.gradle.internal.buildoption.FeatureFlagListener
import org.gradle.internal.concurrent.CompositeStoppable
import org.gradle.internal.execution.UnitOfWork

				(actual == nil),
				rt.args,
			)
		}
	}
}

func TestValidateFeatureGates(t *testing.T) {
	type featureFlag map[string]bool
	var tests = []struct {
		featureGates featureFlag
		expected     bool
	}{
		{featureFlag{"Unknown": true}, false},
		{featureFlag{"Unknown": false}, false},
	}
	for _, rt := range tests {
		actual := ValidateFeatureGates(rt.featureGates, nil)