*/

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 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:

        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 * _._
    }

        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)

        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 ->

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

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

        then:
        1 * action.execute({it != null})
        0 * action._
    }

    def "executes action against an Ivy instance and returns the result"() {
        def action = Mock(Transformer)

        when:
        def result = manager.withIvy(action)

        then:
        result == "result"

        and:
        1 * action.transform({it != null}) >> "result"
        0 * 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 * action1.execute(project)
        1 * action2.execute(project)
        0 * _._
    }

    def "does not continue executing actions when action fails"() {
        def project = Mock(ProjectInternal)
        def failure = new RuntimeException("Configure action failed")

        when:
        evaluator.evaluate(project, state)

        then:
        1 * action1.execute(project) >> {
            throw failure