cleaner.evaluateSATokens(ctx)

			actions := client.Actions()
			if len(actions) != len(tc.ExpectedActions) {
				t.Fatalf("got %d actions, wanted %d actions", len(actions), len(tc.ExpectedActions))
			}
			for i, action := range actions {
				if len(tc.ExpectedActions) < i+1 {
					t.Errorf("%s: %d unexpected actions: %+v", k, len(actions)-len(tc.ExpectedActions), actions[i:])
					break
				}

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()) {

    private InputChangesAwareTaskAction wrap(final Action<? super Task> action) {
        return wrap(action, "unnamed action");
    }

    private InputChangesAwareTaskAction wrap(final Action<? super Task> action, String actionName) {
        if (action instanceof InputChangesAwareTaskAction) {
            return (InputChangesAwareTaskAction) action;
        }
        if (action instanceof ConfigureUtil.WrappedConfigureAction) {

    private final MutableActionSet<Properties> actions = new MutableActionSet<Properties>();

    /**
     * Adds an action to be executed when properties are transformed.
     * @param action the action to add
     */
    public void addAction(Action<? super Properties> action) {
        actions.add(action);
    }

    /**
     * Transforms a properties object.  This will modify the

// run actions. Note that this function has to be called A) after the
// build actions are complete for all packages being tested, and B)
// before any of the "run test" actions for those packages happen.
// This requirement is enforced by adding making this action ("a")
// dependent on all test package build actions, and making all test
// run actions dependent on this action.

        when:
        getTask().getActions().add(Actions.doNothing())
        getTask().getActions().add(Actions.doNothing())

        then:
        getTask().getActions().size() == 2

        when:
        List<Action<? super Task>> actions = new ArrayList<>()
        actions.add(Actions.doNothing())
        getTask().setActions(actions)

        then:
        getTask().getActions().size() == 1

    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'

    public VariantAttributesRules(ImmutableAttributesFactory attributesFactory) {
        this.attributesFactory = attributesFactory;
    }

    public void addAttributesAction(VariantMetadataRules.VariantAction<? super AttributeContainer> action) {
        actions.add(action);
    }

// limitations under the License.

package resource

// SetupFn is a function used for performing setup actions.
type SetupFn func(ctx Context) error

// TeardownFn is a function used for performing tear-down actions.
type TeardownFn func(ctx Context)

// ShouldSkipFn is a function used for performing skip actions; if it returns true a job is skipped
// Note: function may be called multiple times during the setup process.

@ServiceScope(Scope.Global.class)
public interface ExecutorFactory {
    /**
     * Creates an executor which can run multiple actions concurrently. It is the caller's responsibility to stop the executor.
     *
     * The executor will collect failures thrown by actions and rethrow when the executor is stopped.
     *
     * @param displayName The display name for the this executor. Used for thread names, logging and error message.