import org.gradle.internal.serialize.BaseSerializerFactory.DOUBLE_SERIALIZER
import org.gradle.internal.serialize.BaseSerializerFactory.FILE_SERIALIZER
import org.gradle.internal.serialize.BaseSerializerFactory.FLOAT_SERIALIZER
import org.gradle.internal.serialize.BaseSerializerFactory.INTEGER_SERIALIZER
import org.gradle.internal.serialize.BaseSerializerFactory.LONG_SERIALIZER
import org.gradle.internal.serialize.BaseSerializerFactory.PATH_SERIALIZER

    }

    def "serializes multiple args using the serializer registry that can serialize all types"() {
        given:
        registry2.register(String, BaseSerializerFactory.STRING_SERIALIZER)
        registry2.register(Long, BaseSerializerFactory.LONG_SERIALIZER)

        expect:
        def arraySerializer = serializer.forTypes([String, Long, String] as Class[])

        when:
        def serializer = new MapSerializer(BaseSerializerFactory.LONG_SERIALIZER, stringSerializer)
        Map values = serialize([10L: "one", 2L: "two", 30L: "three"], serializer) as Map

        then:
        values.keySet() as List == [10L, 2L, 30L]
    }

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

        then:

        then:
        result == 12

        and:
        0 * _
    }

    def "reuses calculated value for file across factory instances"() {
        def file = new File("thing.txt")
        def cache = factory.newCache("cache", 12000, calculator, BaseSerializerFactory.INTEGER_SERIALIZER)

        when:

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 spock.lang.Specification

class KeyHasherTest extends Specification {
    def "can reuse to hash more than one key"() {
        def hasher = new KeyHasher(BaseSerializerFactory.LONG_SERIALIZER)

        expect:

import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.internal.serialize.Serializer
import spock.lang.Subject

@Subject(LogEventSerializer)
class LogEventSerializerTest extends LogSerializerSpec {
    LogEventSerializer serializer

    def setup() {
        BaseSerializerFactory serializerFactory = new BaseSerializerFactory()

 */
package org.gradle.cache;

import org.gradle.internal.serialize.BaseSerializerFactory;
import org.gradle.internal.serialize.Serializer;

import javax.annotation.Nullable;

public class IndexedCacheParameters<K, V> {
    private static final BaseSerializerFactory SERIALIZER_FACTORY = new BaseSerializerFactory();

    private final String cacheName;
    private final Serializer<K> keySerializer;

import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.internal.serialize.ListSerializer
import org.gradle.internal.serialize.Serializer
import spock.lang.Subject

@Subject(StyledTextOutputEventSerializer)
class StyledTextOutputEventSerializerTest extends LogSerializerSpec {
    StyledTextOutputEventSerializer serializer

    def setup() {
        BaseSerializerFactory serializerFactory = new BaseSerializerFactory()

import org.gradle.internal.serialize.BaseSerializerFactory;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class GeneratedResourceSerializer extends AbstractSerializer<GeneratedResource> {
    private static final Serializer<GeneratedResource.Location> LOCATION_SERIALIZER = new BaseSerializerFactory().getSerializerFor(GeneratedResource.Location.class);

public class WorkerLoggingSerializer {

    public static SerializerRegistry create() {
        DefaultSerializerRegistry registry = new DefaultSerializerRegistry(false);

        BaseSerializerFactory factory = new BaseSerializerFactory();
        Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
        Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);

        // Log events