import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A service that determines whether a feature flag is enabled or not.
 */
@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);

    /**

 * in that case).
 */
@ListenerService
@ServiceScope(Scope.BuildTree::class)
internal
class DeprecatedFeaturesListener(
    private val featureFlags: FeatureFlags,
    private val buildModelParameters: BuildModelParameters
) : BuildScopeListenerRegistrationListener, TaskExecutionAccessListener, ExecutionAccessListener {

    ScriptHandlerFactory scriptHandlerFactory = Mock(ScriptHandlerFactory)
    ScriptHandler settingsScriptHandler = Mock(ScriptHandler)
    DefaultPluginManager pluginManager = Mock(DefaultPluginManager)
    FeatureFlags previews = Mock(FeatureFlags)
    DefaultSettings settings

    def createSettings(String path = '/somepath/root') {
        settingsDir = new File(path).absoluteFile

    private final ClassPath classPath;
    private final DependenciesAccessorsWorkspaceProvider workspace;
    private final DefaultProjectDependencyFactory projectDependencyFactory;
    private final FeatureFlags featureFlags;
    private final ExecutionEngine engine;
    private final FileCollectionFactory fileCollectionFactory;
    private final InputFingerprinter inputFingerprinter;

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.gradle.api.internal.FeaturePreviews
import org.gradle.internal.buildoption.FeatureFlags

class ConfigurationCacheFeatureFlagsIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "toggling feature flag with system property invalidates cache"() {
        given:

package org.gradle.internal.buildoption;

import org.gradle.internal.event.ListenerManager;

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;

        val featureFlags = gradle.serviceOf<FeatureFlags>()
        val enabledFeatures = FeaturePreviews.Feature.values().filter { featureFlags.isEnabledWithApi(it) }
        writeCollection(enabledFeatures)
    }

    private
    suspend fun DefaultReadContext.readPreviewFlags(gradle: GradleInternal) {
        val featureFlags = gradle.serviceOf<FeatureFlags>()
        readCollection {

        FeatureFlags featureFlags,
        FileCollectionFactory fileCollectionFactory,
        ImmutableAttributesFactory attributesFactory,
        CapabilityNotationParser capabilityNotationParser,
        InputFingerprinter inputFingerprinter
    ) {

        ServiceRegistry services,
        ListenerManager listenerManager,
        IsolatableFactory isolatableFactory,
        SharedResourceLeaseRegistry sharedResourceLeaseRegistry,
        FeatureFlags featureFlags
    ) {
        // TODO:configuration-cache remove this hack
        // HACK: force the instantiation of FlowScope so its listeners are registered before DefaultBuildServicesRegistry's

import org.gradle.configuration.ScriptPluginFactory;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.Actions;
import org.gradle.internal.buildoption.FeatureFlags;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.internal.management.DependencyResolutionManagementInternal;
import org.gradle.internal.management.ToolchainManagementInternal;