*/

package org.gradle.internal.serialize

import java.nio.file.Path
import java.nio.file.Paths

class BaseSerializerFactoryTest extends SerializerSpec {
    def factory = new BaseSerializerFactory()

    def "uses efficient serialization for Strings"() {
        expect:
        def serializer = factory.getSerializerFor(String)
        usesEfficientSerialization("hi", serializer, 3) == "hi"
    }

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.serialize.BaseSerializerFactory;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.HashCodeSerializer;
import org.gradle.internal.serialize.Serializer;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class TestEventSerializer {
    public static SerializerRegistry create() {
        BaseSerializerFactory factory = new BaseSerializerFactory();
        DefaultSerializerRegistry registry = new DefaultSerializerRegistry();
        registry.register(DefaultTestClassRunInfo.class, new DefaultTestClassRunInfoSerializer());

import org.gradle.internal.file.FileAccessTracker
import org.gradle.internal.hash.TestHashCodes
import org.gradle.internal.resource.metadata.DefaultExternalResourceMetaData
import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.internal.BuildCommencedTimeProvider
import org.junit.Rule
import spock.lang.Specification

        val key = read() as K
        val value = read() as V
        items[key] = value
    }
}


fun Encoder.writeFile(file: File) {
    BaseSerializerFactory.FILE_SERIALIZER.write(this, file)
}


fun Decoder.readFile(): File =
    BaseSerializerFactory.FILE_SERIALIZER.read(this)


fun Encoder.writeStrings(strings: Collection<String>) {
    writeCollection(strings) {
        writeString(it)
    }

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

    def "serialize list of longs"() {
        when:
        def serializer = new ListSerializer(BaseSerializerFactory.LONG_SERIALIZER)

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

    def "serialize null entry"() {
        when:

            implicits.put(serviceName, input);
        }
    }

    private static class AnySerializer implements Serializer<Object> {
        private static final BaseSerializerFactory SERIALIZER_FACTORY = new BaseSerializerFactory();

        private static final Class<?>[] USUAL_TYPES = new Class<?>[]{
            String.class,
            Boolean.class,
            Long.class,
            File.class,

import org.gradle.internal.reflect.JavaReflectionUtil
import org.gradle.internal.resource.StringTextResource
import org.gradle.internal.resource.TextResource
import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.serialize.kryo.KryoBackedDecoder
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.SetSystemProperties

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

    def "serialize set of longs"() {
        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:

import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification
import spock.lang.Subject

import static org.gradle.internal.serialize.BaseSerializerFactory.STRING_SERIALIZER

class AbstractCachedIndexTest extends Specification {

    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())