Object id = idSerializer.read(decoder);
            String className = decoder.readString();
            String classDisplayName = decoder.readString();
            String name = decoder.readString();
            String displayName = decoder.readString();
            return new DefaultTestDescriptor(id, className, name, classDisplayName, displayName);
        }

        @Override

                HashCode classLoaderHash = hashCodeSerializer.read(decoder);
                String functionalInterfaceClass = decoder.readString();
                String implClass = decoder.readString();
                String implMethodName = decoder.readString();
                String implMethodSignature = decoder.readString();
                int implMethodKind = decoder.readSmallInt();
                return new LambdaImplementationSnapshot(

        decode(bytes) { Decoder decoder ->
            decoder.decodeChunked { Decoder nested ->
                assert nested.readSmallInt() == 12
                assert nested.readString() == "chunked"
            }
            assert decoder.readString() == "done"
        }
    }

    def "can encode and decode multiple byte streams"() {
        when:
        def bytes = encode { Encoder encoder ->

        } else {
            ownerService<ClassLoaderScopeRegistry>().coreAndPluginsScope
        }

        val name = readString()
        val origin = if (readBoolean()) {
            ClassLoaderScopeOrigin.Script(readString(), Describables.of(readString()), Describables.of(readString()))
        } else {
            null
        }
        val localClassPath = readClassPath()

            gradleHomeDir = new File(decoder.readString());
            daemonBaseDir = new File(decoder.readString());
            idleTimeoutMs = decoder.readSmallInt();
            periodicCheckIntervalMs = decoder.readSmallInt();
            singleUse = decoder.readBoolean();
            nativeServicesMode = NativeServicesMode.values()[decoder.readSmallInt()];
            daemonUid = decoder.readString();

        def input2 = encoded("string 2")

        given:
        def decoder = new KryoBackedDecoder(input1)
        decoder.readString()
        decoder.restart(input2)

        expect:
        decoder.readPosition == 0
        decoder.readString() == "string 2"
        decoder.readInt() == 12
    }

    InputStream encoded(String text) {
        def stream = new ByteArrayOutputStream()

    }

    @Override
    public TextQuestionPromptEvent read(Decoder decoder) throws Exception {
        return new TextQuestionPromptEvent(decoder.readLong(), decoder.readString(), decoder.readString());
    }

		}
		switch msgp.UnsafeString(field) {
		case "id":
			z.DiskID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "DiskID")
				return
			}
		case "v":
			z.Volume, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Volume")
				return
			}
		case "fp":
			z.FilePath, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "FilePath")
				return

            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());
            Long pid = decoder.readBoolean() ? decoder.readLong() : null;

            int pairs = decoder.readSmallInt();
            ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
            for (int i = 0; i < pairs; ++i) {
                builder.put(decoder.readString(), decoder.readString());
            }
            return builder.build();
        }

        @Override
        public void write(Encoder encoder, Map<String, String> value) throws Exception {