out.write('HELLO'.getBytes("UTF-8"))
            byteBuffer.readAsString("UTF-8") == 'HELLO'
            byteBuffer.readAsString() == ''
            byteBuffer.readAsString() == ''
        }
        out.write(TEST_STRING_BYTES)

        then:
        byteBuffer.readAsString("UTF-8") == TEST_STRING

        where:

        }
        return listOfByteArrays;
    }

    public String readAsString(String encoding) {
        Charset charset = Charset.forName(encoding);
        return readAsString(charset);
    }

    public String readAsString() {
        return readAsString(Charset.defaultCharset());
    }

    public String readAsString(Charset charset) {
        try {
            return doReadAsString(charset);

        byte currentByte = (byte) (b & 0xff);
        return currentByte == lastLineSeparatorByte || currentByte == '\n';
    }

    @Override
    public void flush() {
        String text = buffer.readAsString();
        if (text.length() > 0) {
            handler.text(text);
        }
        counter = 0;
    }

            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());
    }