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)

     *
     * @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)) {

 */

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

        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:

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

 */

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

	deletionGracePeriod := int64(10)
	terminationGracePeriod := int64(10)
	lifecycle := &v1.Lifecycle{
		// Left PostStart as nil
		PreStop: &v1.LifecycleHandler{
			Exec: &v1.ExecAction{
				Command: []string{"action1", "action2"},
			},
			HTTPGet: &v1.HTTPGetAction{
				Path:   "path",
				Host:   "host",
				Port:   intstr.FromInt32(8080),
				Scheme: "scheme",
			},
			TCPSocket: &v1.TCPSocketAction{

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