selectedVariants >> [v1, v2]
            repositoryName >> 'repoName'
        }

        when:
        def serialized = serialize(component)
        def result = deserialize(serialized)

        then:
        result.id == componentIdentifier
        result.selectionReason == ComponentSelectionReasons.requested()

    def encoder = new OutputStreamBackedEncoder(output)

    @Subject
    def serializer = new SnapshotSerializer(Mock(ClassLoaderHierarchyHasher))

    def "serializes serialized properties"() {
        def original = snapshot("x".bytes)
        write(original)

        expect:
        original == written
    }

    def "serializes string properties"() {
        def original = string("x")
        write(original)

import org.gradle.internal.serialize.SerializerSpec
import org.gradle.util.Path

class ComponentIdentifierSerializerTest extends SerializerSpec {
    ComponentIdentifierSerializer serializer = new ComponentIdentifierSerializer()

    def "throws exception if null is provided"() {
        when:
        serialize(null, serializer)

        then:

        private final Serializer<Object>[] serializers;

        ArraySerializer(Serializer<Object>[] serializers) {
            this.serializers = serializers;
        }

        @Override
        public Object[] read(Decoder decoder) throws Exception {
            Object[] result = new Object[serializers.length];
            for (int i = 0; i < serializers.length; i++) {
                result[i] = serializers[i].read(decoder);

        when:
        ModuleComponentSelector result1 = serialize(selector1, serializer)
        ModuleComponentSelector result2 = serialize(selector2, serializer)
        ModuleComponentSelector result3 = serialize(selector3, serializer)

        then:
        result1.attributes == AttributeTestUtil.attributes("foo": "val1")

var serializerMap = sync.Map{}

// RegisterSerializer register serializer
func RegisterSerializer(name string, serializer SerializerInterface) {
	serializerMap.Store(strings.ToLower(name), serializer)
}

// GetSerializer get serializer
func GetSerializer(name string) (serializer SerializerInterface, ok bool) {
	v, ok := serializerMap.Load(strings.ToLower(name))
	if ok {
		serializer, ok = v.(SerializerInterface)
	}
	return serializer, ok
}

    def "falls back to default when no serializer registry knows about types"() {
        given:
        def serializer = Stub(Serializer)
        defaultArgsBuilder.forTypes(_) >> serializer

        expect:
        this.serializer.forTypes([String, Long, String] as Class[]) == serializer
    }

    }

    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[])

 */

package org.gradle.internal.logging.serializer;

import org.gradle.internal.logging.events.ProgressStartEvent;
import org.gradle.internal.operations.BuildOperationCategory;
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.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