def container = parent.containerWithType(CreatedSubType)
        def action = { CreatedSubType subType ->
            subType.value = "actioned"
        } as Action<CreatedSubType>

        and:
        container.create("created1")
        container.create("created2", {
            it.value = "changed"
        })
        container.create("created3", action)

        then:

        def action3 = Mock(Action)
        def action4 = Mock(Action)
        def action5 = Mock(Action)
        def action6 = Mock(Action)

        when:
        def set = ImmutableActionSet.of(action1, action2)
        set = set.add(action1)
        set = set.add(action2)
        set = set.add(ImmutableActionSet.of(action2, action1))
        set.execute("value")

        then:

        then:
        result == ["one", "two", "three"]

        1 * buildModelParameters.isParallelToolingApiActions() >> false
        1 * action1.get() >> "one"
        1 * action2.get() >> "two"
        1 * action3.get() >> "three"
        0 * _
    }

    def "queues supplied actions to run in parallel"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)

// An Actor runs an action.
type Actor interface {
	Act(*Builder, context.Context, *Action) error
}

// An ActorFunc is an Actor that calls the function.
type ActorFunc func(*Builder, context.Context, *Action) error

func (f ActorFunc) Act(b *Builder, ctx context.Context, a *Action) error {
	return f(b, ctx, a)
}

// An Action represents a single action in the action graph.
type Action struct {

     *
     * @param actions The actions to make a composite of.
     * @param <T> The type of the object that action is for
     * @return The composite action.
     */
    public static <T> Action<T> composite(Iterable<? extends Action<? super T>> actions) {
        ImmutableList.Builder<Action<? super T>> builder = ImmutableList.builder();
        for (Action<? super T> action : actions) {
            if (doesSomething(action)) {

    }

    def "captures exceptions from both task action and async work"() {
        given:
        task.getTaskActions() >> [action1, action2]
        task.hasTaskActions() >> true
        action1.execute(task) >> {
            throw new RuntimeException("failure from task action")
        }

        when:
        executer.execute(task, state, executionContext)

        1 * action.execute(task)
        0 * action._
    }

    void "container and task specific configuration actions are executed when task is created"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def action3 = Mock(Action)
        def action4 = Mock(Action)
        def action5 = Mock(Action)
        def action6 = Mock(Action)
        def task = task("task")

 */

package org.gradle.integtests.tooling.r32;

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;

import java.util.Collections;
import java.util.List;

public class Action2 implements BuildAction<List<String>> {
    @Override
    public List<String> execute(BuildController controller) {

        manager.withPlugin("bar", action2)

        then:
        2 * action1.execute(_) >> { AppliedPlugin p ->
            assert p.id == "foo"
        }
        2 * action2.execute(_) >> { AppliedPlugin p ->
            assert p.id == "bar"
        }
        0 * action1._
        0 * action2._
    }

    def "action is notified for plugin with org.gradle id"() {

        1 == defaultTask.actions.size()

        defaultTask.is(defaultTask.doFirst(action2))
        2 == defaultTask.actions.size()

        action2.is(defaultTask.actions[0].action)
        action1.is(defaultTask.actions[1].action)
    }

    def "doLast() adds action to the end of actions list"() {
        given:
        Action<Task> action1 = Actions.doNothing()