}

    def "serializes single args"() {
        expect:
        def arraySerializer = serializer.forTypes([String,] as Class[])
        serialize(["a"] as Object[], arraySerializer) == ["a"] as Object[]
    }

    def "serializes multiple args"() {
        expect:
        def arraySerializer = serializer.forTypes([String, Long, String] as Class[])

import org.gradle.internal.Describables
import org.gradle.internal.serialize.AbstractDecoder
import org.gradle.internal.serialize.AbstractEncoder
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.serialize.SerializerSpec
import org.gradle.internal.serialize.kryo.StringDeduplicatingKryoBackedDecoder
import org.gradle.internal.serialize.kryo.StringDeduplicatingKryoBackedEncoder

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

    }

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

 */

package org.gradle.groovy.scripts.internal

import org.gradle.internal.serialize.SerializerSpec

class BuildScriptDataSerializerTest extends SerializerSpec {
    def serializer = new BuildScriptDataSerializer()

    def "serializes data"() {
        given:
        def value = new BuildScriptData(true)
        def result = serialize(value, serializer)

        expect:
        result.hasImperativeStatements
    }

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.