import org.gradle.internal.remote.internal.MessageIOException
import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.internal.serialize.Decoder
import org.gradle.internal.serialize.Encoder
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.serialize.Serializers
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.test.precondition.Requires

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

        then:
        serialize([1L, 5L, 99L] as Set, serializer) as List == [1L, 5L, 99L]
    }

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

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

import org.gradle.internal.id.CompositeIdGenerator
import org.gradle.internal.serialize.SerializerSpec

class TestEventSerializerTest extends SerializerSpec {
    def serializer = TestEventSerializer.create()

    def "serializes DefaultTestClassRunInfo"() {
        def info = new DefaultTestClassRunInfo("some-test")

        when:
        def result = serialize(info)

        then:
        result instanceof DefaultTestClassRunInfo

        return fromBytes(bytes, serializer)
    }

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

    <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()
        def encoder = getEncoder().newInstance(bytes)
        serializer.write(encoder, value)
        encoder.flush()

 * limitations under the License.
 */

package org.gradle.internal.serialize;

public interface SerializerRegistry {
    /**
     * Use the given serializer for objects of the given type.
     * <p>
     * The provided serializer must be thread-safe and reusable.
     */
    <T> void register(Class<T> implementationType, Serializer<T> serializer);

    /**

    }

    def "serialize map"() {
        when:
        def serializer = new MapSerializer(BaseSerializerFactory.LONG_SERIALIZER, stringSerializer)

        then:
        serialize([1L: "one", 2L: "two", 3L: "three"], serializer) == [1L: "one", 2L: "two", 3L: "three"]
    }

    def "serialize null value"() {
        when:

    private final Serializer<Message> serializer;

    private boolean started;
    private boolean stopped;
    private final Lock lifecycleLock = new ReentrantLock();
    private ConnectionAcceptor acceptor;

    public DaemonTcpServerConnector(ExecutorFactory executorFactory, InetAddressFactory inetAddressFactory, Serializer<Message> serializer) {
        this.serializer = serializer;

    private serializer = new ModuleComponentSelectorSerializer(new DesugaredAttributeContainerSerializer(attributesFactory(), TestUtil.objectInstantiator()))

    def "serializes"() {
        when:
        def result = serialize(newSelector(UTIL, constraint(version, strict, rejects), attributes(foo: 'bar'), [capability("foo")]), serializer)

        then:

import org.gradle.internal.serialize.InputStreamBackedDecoder
import org.gradle.internal.serialize.OutputStreamBackedEncoder
import spock.lang.Specification

import static org.gradle.api.internal.artifacts.DefaultModuleVersionSelector.newSelector

class DependencyResultSerializerTest extends Specification {

* Existing usages of Serializer outside of this infrastructure should be migrated to use it.
* Existing usages of Java serialization should be migrated to use it.
* It is ok for Serializer to be used as a replacement for Java serialization as a migration step.