def startParameter = Mock(StartParameterInternal)
    def action = Mock(SerializedPayload)
    def clientSubscriptions = Mock(BuildEventSubscriptions)
    def payloadSerializer = Mock(PayloadSerializer)
    def gradle = Stub(GradleInternal)
    def buildController = Mock(BuildTreeLifecycleController) {
        getGradle() >> this.gradle
    }
    def modelController = Stub(BuildTreeModelController)

        this.payloadSerializer = payloadSerializer;
    }

    public DefaultBuildController controllerFor(BuildTreeModelController controller) {
        return new DefaultBuildController(controller, workerThreadRegistry, buildCancellationToken, buildStateRegistry, parameterCarrierFactory, buildEventConsumer, sideEffectExecutor, payloadSerializer);
    }

        BuildControllerFactory buildControllerFactory,
        PayloadSerializer payloadSerializer,
        BuildEventConsumer buildEventConsumer,
        BuildTreeModelSideEffectExecutor sideEffectExecutor
    ) {
        super(buildControllerFactory, payloadSerializer);
        this.payloadSerializer = payloadSerializer;
        this.buildEventConsumer = buildEventConsumer;

import org.gradle.tooling.internal.provider.serialization.PayloadSerializer
import org.gradle.tooling.internal.provider.serialization.SerializedPayload

class PhasedActionEventConsumerTest extends Specification {
    def phasedActionResultListener = Mock(PhasedActionResultListener)
    def delegateEventConsumer = Mock(BuildEventConsumer)
    def payloadSerializer = Stub(PayloadSerializer)

import org.gradle.tooling.internal.provider.connection.ProviderOperationParameters
import org.gradle.tooling.internal.provider.serialization.PayloadSerializer
import org.gradle.util.GradleVersion
import spock.lang.Specification

class ProviderConnectionTest extends Specification {
    def payloadSerializer = Mock(PayloadSerializer)

    def "ignores unknown operation types"() {
        given:
        def parameters = Stub(ProviderOperationParameters) {

    private final BuildEventConsumer buildEventConsumer;
    private final BuildTreeModelSideEffectExecutor sideEffectExecutor;
    private final PayloadSerializer payloadSerializer;

    public DefaultBuildController(
        BuildTreeModelController controller,
        WorkerThreadRegistry workerThreadRegistry,
        BuildCancellationToken cancellationToken,

    def sideEffectExecutor = Mock(BuildTreeModelSideEffectExecutor)
    def payloadSerializer = Mock(PayloadSerializer)
    def controller = new DefaultBuildController(modelController, workerThreadRegistry, cancellationToken, buildStateRegistry, parameterCarrierFactory, buildEventConsumer, sideEffectExecutor, payloadSerializer)

    def "cannot get build model from unmanaged thread"() {
        given:

import java.lang.reflect.Proxy

class PayloadSerializerTest extends AbstractClassGraphSpec {
    final PayloadSerializer originator = new PayloadSerializer(new WellKnownClassLoaderRegistry(new DefaultPayloadClassLoaderRegistry(new ClassLoaderCache(), new ModelClassLoaderFactory())))

                new ModelClassLoaderFactory(),
                cachedClasspathTransformer);
        }

        @Provides
        PayloadSerializer createPayloadSerializer(ClassLoaderCache classLoaderCache, PayloadClassLoaderFactory classLoaderFactory) {
            return new PayloadSerializer(
                new WellKnownClassLoaderRegistry(
                    new DefaultPayloadClassLoaderRegistry(
                        classLoaderCache,

                        encoder.writeByte((byte) 2);
                        payloadSerializer.write(encoder, result.getResult());
                    }
                } else if (result.getFailure() != null) {
                    encoder.writeByte((byte) 3);
                    encoder.writeBoolean(result.wasCancelled());
                    payloadSerializer.write(encoder, result.getFailure());
                } else {