import org.gradle.api.Action;
import org.gradle.api.internal.project.ProjectInternal;

public class DelayedConfigurationActions implements ProjectConfigureAction {
    @Override
    public void execute(ProjectInternal projectInternal) {
        ProjectConfigurationActionContainer actions = projectInternal.getConfigurationActions();
        try {
            for (Action<? super ProjectInternal> action : actions.getActions()) {

----
====
<1> Use service injection to obtain `FlowScope` and `FlowProviders` instances. They are available for project and settings plugins.
<2> Use an appropriate scope to run your actions. As the name suggests, actions in the `always` scope are executed every time the build runs.
<3> Specify the class that implements the action.

    }

    public ToolType getToolType() {
        return toolType;
    }

    @Override
    public void withArguments(Action<? super List<String>>  action) {
        argActions.add(action);
    }

    @Override
    public Action<List<String>> getArgAction() {
        return Actions.composite(argActions);
    }

    ProgressEvents events

    def setup() {
        events = ProgressEvents.create()
        settingsFile << "rootProject.name = 'root'"
    }

    //This is not a task action, but it is logged on the same level as the actions
    def "clean stale output action has an informative name"() {
        given:
        buildFile << """
            apply plugin: 'base'

            task custom {
                outputs.dir 'build/outputs'

                    actions.add(action);
                    if (!(action instanceof ContinuingAction)) {
                        break;
                    }
                }
            }

            if (!actions.isEmpty()) {
                return Actions.composite(actions);
            }

            throw new UnsupportedOperationException("No action factory for specified command-line arguments.");
        }

        linker.execute(spec)

        then:
        1 * operationLogger.getLogLocation() >> LOG_LOCATION
        1 * buildOperationExecutor.runAll(commandLineTool, _) >> { worker, action -> action.execute(queue) }
        1 * invocationContext.getArgAction() >> Actions.doNothing()
        1 * invocationContext.createInvocation("linking lib", outputFile.parentFile, expectedArgs, operationLogger) >> invocation
        1 * queue.add(invocation)

    }

    @Override
    public void all(Action<? super CapabilityResolutionDetails> action) {
        actions.add(new CapabilityAction(Specs.SATISFIES_ALL, action));
    }

    @Override
    public void withCapability(Capability capability, Action<? super CapabilityResolutionDetails> action) {
        withCapability(Providers.of(capability), action);
    }

    @Override

	if err == nil {
		actions := ""
		for _, action := range mockClient.Actions() {
			actions = actions + action.GetVerb() + ":" + action.GetResource().Resource + ":" + action.GetSubresource() + ", "
		}
		t.Errorf("expected error returned from admission handler: %v", actions)
	}

    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately after a project is evaluated.
     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions
     * @since 8.8
     */
    @Incubating
    void afterProject(IsolatedAction<? super Project> action);

        def copy = substitutions.copy()

        when:
        copy.all(Mock(Action))

        then:
        0 * validator.validateMutation(_)
    }

    def "registering an all rule toggles the hasRule flag"() {
        given:
        def action = Mock(Action)

        when:
        substitutions.all(action)

        then:
        substitutions.rulesMayAddProjectDependency()
    }