def cl1 = new URLClassLoader([implJar.toURI().toURL()] as URL[], getClass().classLoader)
        def action1 = cl1.loadClass("ActionImpl").getConstructor().newInstance()

        when:
        File actualJar1 = withConnection { ProjectConnection connection ->
            connection.action(action1).run()
        }
        cl1.close()
        Files.delete(implJar.toPath())

        then:

        def action1 = Mock(Action)
        def action2 = Mock(Action)

        given:
        container.actions >> [action1, action2]

        when:
        action.execute(project)

        then:
        1 * action1.execute(project)
        1 * action2.execute(project)

        and:
        1 * container.finished()
    }

    def "discards actions on failure"() {

 */
package org.gradle.api;

/**
 * Performs some action against objects of type T.
 *
 * @param <T> The type of object which this action accepts.
 */
@HasImplicitReceiver
public interface Action<T> {
    /**
     * Performs this action against the given object.
     *
     * @param t The object to perform the action on.
     */
    void execute(T t);

        copyClassTo(Action2, classesDir2)
        copyClassTo(SharedActionStaticState, classesDir2)
        def cl1 = actionClassLoader(classesDir1)
        def action1 = cl1.loadClass(Action1.name)
        assert action1 != Action1
        def cl2 = actionClassLoader(classesDir2)
        def action2 = cl2.loadClass(Action2.name)
        assert action2 != Action2

        expect:
        def l1 = withConnection { c ->

        0 * action._
    }

    def broadcastsEventsToMultipleActions() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        broadcast.add(action1)
        broadcast.add(action2)

        when:
        broadcast.execute('value')

        then:
        1 * action1.execute('value')
        1 * action2.execute('value')
        0 * _._
    }

    }

    def testSetActions() {
        when:
        Action action1 = Actions.doNothing()
        getTask().actions = [action1]

        Action action2 = Actions.doNothing()
        getTask().actions = [action2]

        then:
        [new AbstractTask.TaskActionWrapper(action2, "doLast(Action)")] ==  getTask().actions
    }

    def testAddActionWithNull() {
        when:

        executor.execute(action1)
        executor.execute(action2)
        executor.execute(action3)
        thread.blockUntil.started3

        then:
        instant.started3 > instant.completed1
        instant.started3 > instant.started2

        cleanup:
        executor?.stop()
    }

    def stopBlocksUntilAllJobsAreComplete() {
        given:
        def action1 = {
            thread.block()

        outputs.stdOut.contains(expectedText)
        outputs.stdOut.contains("action1")
        !action1Intermediary || outputs.stdOut.contains("action2")

        and:
        1 * actionFactory1.createAction(!null, !null) >> {
            def action1 = { println "action1" }
            action1Intermediary ? action1 as ContinuingAction<ExecutionListener> : action1 as Action<ExecutionListener>

        }

 */

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 Action1 implements BuildAction<List<String>> {
    @Override
    public List<String> execute(BuildController controller) {

        def binary2 = Stub(SwiftBinary)
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def finalizeAction = Mock(Action)

        spec.isSatisfiedBy(binary2) >> true

        given:
        def p = container.get(spec)
        p.whenFinalized(finalizeAction)
        p.configure(action1)
        container.configureEach(action2)
        container.add(binary1)