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

        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:

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

import org.gradle.cache.CacheDecorator
import org.gradle.cache.PersistentCache
import org.gradle.cache.internal.DefaultInMemoryCacheDecoratorFactory
import org.gradle.internal.serialize.BaseSerializerFactory
import org.gradle.internal.snapshot.FileSystemLocationSnapshot
import org.gradle.test.fixtures.file.CleanupTestDirectory
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

 * limitations under the License.
 */

package org.gradle.internal.logging.serializer;

import org.gradle.internal.logging.events.SelectOptionPromptEvent;
import org.gradle.internal.serialize.BaseSerializerFactory;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.ListSerializer;
import org.gradle.internal.serialize.Serializer;

import static org.gradle.api.internal.changedetection.state.DefaultFileAccessTimeJournal.INCEPTION_TIMESTAMP_KEY
import static org.gradle.internal.serialize.BaseSerializerFactory.FILE_SERIALIZER
import static org.gradle.internal.serialize.BaseSerializerFactory.LONG_SERIALIZER

trait FileAccessTimeJournalFixture extends CachingIntegrationFixture {
    TestFile getJournal() {

import org.gradle.api.specs.Spec;
import org.gradle.cache.internal.FileContentCache;
import org.gradle.cache.internal.FileContentCacheFactory;
import org.gradle.internal.serialize.BaseSerializerFactory;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

 */

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"
    }

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