expect:
        def bytes = encode { Encoder encoder ->
            encoder.outputStream.write(Byte.MIN_VALUE)
            encoder.outputStream.write(Byte.MAX_VALUE)
            encoder.outputStream.write(-1)
            encoder.outputStream.write([1, 2, 3, 4] as byte[])
            encoder.outputStream.write([0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7] as byte[], 2, 4)
        }

        }

        @Override
        public void write(Encoder encoder, ClassAnalysis value) throws Exception {
            encoder.writeString(value.getClassName());
            encoder.writeNullableString(value.getDependencyToAllReason());
            stringSetSerializer.write(encoder, value.getPrivateClassDependencies());
            stringSetSerializer.write(encoder, value.getAccessibleClassDependencies());

        }

        @Override
        public void write(Encoder encoder, Map<String, String> value) throws Exception {
            encoder.writeSmallInt(value.size());
            for (Map.Entry<String, String> entry : value.entrySet()) {
                encoder.writeString(entry.getKey());
                encoder.writeString(entry.getValue());
            }
        }
    }

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

public class BooleanQuestionPromptEventSerializer implements Serializer<BooleanQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, BooleanQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());

        }

        @Override
        public void write(Encoder encoder, Build build) throws Exception {
            encoder.writeLong(build.getIdentifier().getMostSignificantBits());
            encoder.writeLong(build.getIdentifier().getLeastSignificantBits());
            encoder.writeBinary(build.getToken());
            encoder.writeLong(build.getStartTime());
            encoder.writeBoolean(build.isInteractive());

        }
        return valueMap;
    }

    @Override
    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }

    @Override
    public boolean equals(Object obj) {

    }

    private void writeName(String name, Encoder encoder) throws IOException {
        Integer id = namesById.inverse().get(name);
        if (id == null) {
            id = namesById.inverse().size();
            namesById.inverse().put(name, id);
            encoder.writeSmallInt(id);
            writeFirstOccurrenceOfName(name, encoder);
        } else {
            encoder.writeSmallInt(id);
        }
    }

        }
        write(_, _) >> { Encoder encoder, Long value ->
            encoder.writeSmallLong(value)
        }
    }
    def intSerializer = Stub(Serializer) {
        read(_) >> { Decoder decoder ->
            return decoder.readSmallInt()
        }
        write(_, _) >> { Encoder encoder, Integer value ->
            encoder.writeSmallInt(value)
        }
    }

            encoder.writeBoolean(singleUse);
            encoder.writeSmallInt(daemonParameters.getNativeServicesMode().ordinal());
            encoder.writeString(daemonUid);
            encoder.writeSmallInt(daemonParameters.getPriority().ordinal());
            encoder.writeSmallInt(daemonOpts.size());
            for (String daemonOpt : daemonOpts) {
                encoder.writeString(daemonOpt);
            }

            return new JvmMemoryStatusSnapshot(maxMemory, committedMemory);
        }

        @Override
        public void write(Encoder encoder, JvmMemoryStatus jvmMemoryStatus) throws Exception {
            encoder.writeLong(jvmMemoryStatus.getCommittedMemory());
            encoder.writeLong(jvmMemoryStatus.getMaxMemory());
        }
    }