* limitations under the License.
 */

package org.gradle.internal.logging.serializer;

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

public class TextQuestionPromptEventSerializer implements Serializer<TextQuestionPromptEvent> {
    @Override

 * limitations under the License.
 */

package org.gradle.internal.logging.serializer;

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

public class YesNoQuestionPromptEventSerializer implements Serializer<YesNoQuestionPromptEvent> {
    @Override

     */
    MultiRequestClient<IN, OUT> build();

    /**
     * Registers a serializer to use when handling arguments to methods of {@link T}.
     */
    <T> void registerArgumentSerializer(Class<T> type, Serializer<T> serializer);

    /**
     * Use a simpler classloader structure where everything is in the application classloader.
     */

 */

package org.gradle.internal.logging.serializer

import org.gradle.api.logging.LogLevel
import org.gradle.internal.logging.events.UserInputResumeEvent
import spock.lang.Subject

class UserInputResumeEventSerializerTest extends LogSerializerSpec {

    @Subject def serializer = new UserInputResumeEventSerializer()

    def "can serialize user input resume event"() {
        given:

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used
 * as cache parameter which need to be compared to determine compatible cache.
 */

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

import java.util.ArrayList;
import java.util.List;

public class SerializedPayloadSerializer implements Serializer<SerializedPayload> {
    private final Serializer<Object> javaSerializer = new DefaultSerializer<Object>();

        Object o = cl.newInstance(new Object[0])

        when:
        def r = serialize(o, serializer)

        then:
        cl.isInstance(r)
    }

    def "returns true when testing equality between two serializer with the same classloader"() {
        DefaultSerializer rhsSerializer = new DefaultSerializer(getClass().classLoader)

 */
package org.gradle.internal.serialize;

import com.google.common.base.Objects;

import java.io.EOFException;
import java.util.Collection;

public abstract class AbstractCollectionSerializer<T, C extends Collection<T>> implements Serializer<C> {
    protected final Serializer<T> entrySerializer;

    public AbstractCollectionSerializer(Serializer<T> entrySerializer) {

 */

package org.gradle.internal.serialize;

import com.google.common.base.Objects;
import com.google.common.collect.Sets;

import java.util.Collections;
import java.util.Set;

public class SetSerializer<T> extends AbstractCollectionSerializer<T, Set<T>> implements Serializer<Set<T>> {

    private final boolean linkedHashSet;

    public SetSerializer(Serializer<T> entrySerializer) {

    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)