when:
        def serializer = new ListSerializer(BaseSerializerFactory.LONG_SERIALIZER)

        then:
        serialize([10L, 5L, 99L], serializer) == [10L, 5L, 99L]
    }

    def "serialize null entry"() {
        when:
        def serializer = new ListSerializer(stringSerializer)

        then:
        serialize(["one", null, "three"], serializer) == ["one", null, "three"]
    }

class StyledTextOutputEventSerializerTest extends LogSerializerSpec {
    StyledTextOutputEventSerializer serializer

    def setup() {
        BaseSerializerFactory serializerFactory = new BaseSerializerFactory()
        Serializer<LogLevel> logLevelSerializer = serializerFactory.getSerializerFor(LogLevel.class)
        serializer = new StyledTextOutputEventSerializer(
            logLevelSerializer,

    private final FileAccess fileAccess;
    private final Serializer<T> serializer;
    private final Chmod chmod;
    private final File cacheFile;

    public FileBackedObjectHolder(File cacheFile, FileAccess fileAccess, Serializer<T> serializer, Chmod chmod) {
        this.cacheFile = cacheFile;
        this.fileAccess = fileAccess;
        this.serializer = serializer;
        this.chmod = chmod;
    }

    @Override

    LogEventSerializer serializer

    def setup() {
        BaseSerializerFactory serializerFactory = new BaseSerializerFactory()
        Serializer<LogLevel> logLevelSerializer = serializerFactory.getSerializerFor(LogLevel.class)
        Serializer<Throwable> throwableSerializer = serializerFactory.getSerializerFor(Throwable.class)
        serializer = new LogEventSerializer(logLevelSerializer, throwableSerializer)
    }

    public <T> T serialize(T value, Serializer<T> serializer) {
        def bytes = toBytes(value, serializer)
        return fromBytes(bytes, serializer)
    }

    public <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(new KryoBackedDecoder(new ByteArrayInputStream(bytes)))
    }

    public <T> byte[] toBytes(T value, Serializer<T> serializer) {

import org.gradle.internal.operations.OperationIdentifier
import org.gradle.internal.serialize.Decoder
import org.gradle.internal.serialize.Encoder
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.serialize.kryo.KryoBackedDecoder
import org.gradle.internal.serialize.kryo.KryoBackedEncoder
import spock.lang.Specification

class RequestSerializerTest extends Specification {

        when:
        def out = serialize(snapshots, serializer)

        then:
        assertEqualSnapshots(out, snapshots)
    }

    def "reads and writes directory snapshots"() {
        def snapshots =  new DirectorySnapshot("/home/lptr/dev", "dev", DIRECT, hashCodeFrom(1111), [])

        when:
        def out = serialize(snapshots, serializer)

        then:

    private static final OperationIdentifier OPERATION_ID = new OperationIdentifier(1234L)

    ProgressStartEventSerializer serializer

    def setup() {
        serializer = new ProgressStartEventSerializer()
    }

    def "can serialize ProgressStartEvent messages"(BuildOperationCategory category) {
        given:

import org.gradle.internal.serialize.SerializerSpec
import org.gradle.tooling.events.OperationType
import org.gradle.tooling.events.test.internal.DefaultDebugOptions
import org.gradle.tooling.internal.provider.serialization.SerializedPayload

import java.beans.Introspector

class BuildActionSerializerTest extends SerializerSpec {
    def "serializes ExecuteBuildAction with all defaults"() {

 */

package org.gradle.process.internal.worker.request;

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.DefaultSerializerRegistry;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Message;
import org.gradle.internal.serialize.Serializer;
import org.gradle.internal.serialize.SerializerRegistry;

public class RequestArgumentSerializers {