type stripVersionEncoder struct {
	encoder    runtime.Encoder
	serializer runtime.Serializer
	identifier runtime.Identifier
}

func newStripVersionEncoder(e runtime.Encoder, s runtime.Serializer) runtime.Encoder {
	return stripVersionEncoder{
		encoder:    e,
		serializer: s,
		identifier: identifier(e),
	}
}

func identifier(e runtime.Encoder) runtime.Identifier {

import org.gradle.internal.classloader.VisitableURLClassLoader
import org.gradle.internal.serialize.kryo.KryoBackedDecoder
import org.gradle.internal.serialize.kryo.KryoBackedEncoder
import spock.lang.Specification

class TransportableActionExecutionSpecSerializerTest extends Specification {
    def serializer = new TransportableActionExecutionSpecSerializer()
    def outputStream = new ByteArrayOutputStream()

        FileContentCache<V> globalCache = globalFactory.newCache(name, normalizedCacheSize, calculator, serializer);
        FileContentCache<V> localCache = localFactory.newCache(name, normalizedCacheSize, calculator, serializer);
        return new SplitFileContentCache<>(globalCache, localCache, globalCacheLocations);
    }

 * limitations under the License.
 */

package org.gradle.internal.logging.serializer;

import org.gradle.internal.logging.events.IntQuestionPromptEvent;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class IntQuestionPromptEventSerializer implements Serializer<IntQuestionPromptEvent> {
    @Override

    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:

    public static final org.gradle.internal.serialize.Serializer<DefaultDaemonContext> SERIALIZER = new Serializer();

    private final String uid;
    private final File javaHome;
    private final File daemonRegistryDir;
    private final Long pid;
    private final Integer idleTimeout;
    private final Collection<String> daemonOpts;
    private final boolean applyInstrumentationAgent;

 */
package org.gradle.internal.serialize;

import com.google.common.base.Objects;

import java.util.LinkedHashMap;
import java.util.Map;

public class MapSerializer<U, V> extends AbstractSerializer<Map<U, V>> {
    private final Serializer<U> keySerializer;
    private final Serializer<V> valueSerializer;

    public MapSerializer(Serializer<U> keySerializer, Serializer<V> valueSerializer) {

func (n *fakeNegotiater) UniversalDeserializer() runtime.Decoder {
	return n.serializer
}

func (n *fakeNegotiater) EncoderForVersion(serializer runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
	return n.serializer
}

func (n *fakeNegotiater) DecoderToVersion(serializer runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
	return n.serializer
}

func TestConfigurableStorageFactory(t *testing.T) {

 * limitations under the License.
 */

package org.gradle.internal.logging.serializer;

import org.gradle.internal.logging.events.ReadStdInEvent;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class ReadStdInEventSerializer implements Serializer<ReadStdInEvent> {

    @Override

 * limitations under the License.
 */

package org.gradle.internal.logging.serializer;

import org.gradle.internal.logging.events.UserInputRequestEvent;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class UserInputRequestEventSerializer implements Serializer<UserInputRequestEvent> {

    @Override