@Override
        public DefaultDaemonContext read(Decoder decoder) throws Exception {
            String uid = decoder.readNullableString();
            String pathname = decoder.readString();
            File javaHome = new File(pathname);
            JavaLanguageVersion javaVersion = JavaLanguageVersion.of(decoder.readSmallInt());
            File registryDir = new File(decoder.readString());

        new String(content) == "this is some content"
    }

    def "can encode and decode binary content"() {
        def outputStream = new ByteArrayOutputStream()
        def encoder = new EncodedStream.EncodedOutput(outputStream)

        when:
        encoder.write(0)
        encoder.write(127)
        encoder.write(128)
        encoder.write(255)
        encoder.flush()

        then:

	state.decodeUint()
	state.decodeUint()
}

// Since the encoder writes no zeros, if we arrive at a decoder we have
// a value to extract and store. The field number has already been read
// (it's how we knew to call this decoder).
// Each decoder is responsible for handling any indirections associated
// with the data structure. If any pointer so reached is nil, allocation must

                IncludeFileEdge includeFileState = ids.get(id);
                if (includeFileState == null) {
                    String includePath = decoder.readString();
                    HashCode includedBy = null;
                    if (decoder.readBoolean()) {
                        includedBy = hashSerializer.read(decoder);
                    }
                    HashCode resolvedTo = hashSerializer.read(decoder);

    }

    @Override
    public ObjectReader<MethodInvocation> newReader(Decoder decoder) {
        return new MethodInvocationReader(decoder, classLoader, methodArgsSerializer);
    }

    @Override
    public ObjectWriter<MethodInvocation> newWriter(Encoder encoder) {
        return new MethodInvocationWriter(encoder, methodArgsSerializer);
    }

    private static class MethodDetails {

        def decoder = new KryoBackedDecoder(inputStream, 10)
        closure.call(decoder)
    }

    def "can encode and decode empty byte stream"() {
        when:
        def bytes = encode { Encoder encoder ->
            encoder.encodeChunked {}
            encoder.writeString("done")
        }

        then:
        decode(bytes) { Decoder decoder ->
            decoder.decodeChunked {}

        }
        encoder.writeSmallInt(event.getTotalProgress());

        if ((flags & BUILD_OPERATION_ID) != 0) {
            encoder.writeSmallLong(buildOperationId.getId());
        }
    }

    @Override
    public ProgressStartEvent read(Decoder decoder) throws Exception {
        long flags = decoder.readSmallInt();
        OperationIdentifier progressOperationId = new OperationIdentifier(decoder.readSmallLong());

}

func decodeListItem(obj *Unknown, decoders []Decoder) (Object, error) {
	for _, decoder := range decoders {
		// TODO: Decode based on ContentType.
		obj, err := Decode(decoder, obj.Raw)
		if err != nil {
			if IsNotRegisteredError(err) {
				continue
			}
			return nil, err
		}
		return obj, nil
	}
	// could not decode, so leave the object as Unknown, but give the decoders the

        }
    }

    private void writeStatusScheme(Encoder encoder, ComponentMetadata md) throws IOException {
        List<String> statusScheme = md.getStatusScheme();
        encoder.writeSmallInt(statusScheme.size());
        for (String s : statusScheme) {
            encoder.writeString(s);
        }
    }

    private List<String> readStatusScheme(Decoder decoder) throws IOException {
        int size = decoder.readSmallInt();

    }

    @Override
    public ComponentSelectionReason read(Decoder decoder) throws IOException {
        ComponentSelectionDescriptor[] descriptions = readDescriptions(decoder);
        return ComponentSelectionReasons.of(descriptions);
    }

    private ComponentSelectionDescriptor[] readDescriptions(Decoder decoder) throws IOException {
        int size = decoder.readSmallInt();