def store = new DefaultBinaryStore(temp.file("foo.bin"))

        when:
        store.write({ it.writeInt(10) } as BinaryStore.WriteAction)
        store.write({ it.writeString("x") } as BinaryStore.WriteAction)
        def data1 = store.done()
        store.write({ it.writeString("y") } as BinaryStore.WriteAction)
        def data2 = store.done()

        then:
        data1.read({ it.readInt() } as BinaryStore.ReadAction) == 10

public class DefaultStandardOutputRedirector implements StandardOutputRedirector {
    private PrintStream originalStdOut;
    private PrintStream originalStdErr;
    private final WriteAction stdOut = new WriteAction();
    private final WriteAction stdErr = new WriteAction();
    private final PrintStream redirectedStdOut = new LinePerThreadBufferingOutputStream(stdOut);

        store.write({it.writeByte((byte) 1); it.writeByte((byte) 2) } as BinaryStore.WriteAction)
        store.done()
        def store2 = f.createStoreSet().nextBinaryStore()

        then:
        store.file == store2.file

        when:
        store2.write({it.writeByte((byte) 4)} as BinaryStore.WriteAction)
        store2.done()

        then:
        f.createStoreSet().nextBinaryStore().file != store2.file

}


inline fun <T : WriteContext, R> T.withDebugFrame(name: () -> String, writeAction: T.() -> R): R {
    val tracer = this.tracer
    return if (tracer == null) {
        writeAction()
    } else {
        val frameName = name()
        try {
            tracer.open(frameName)
            writeAction()
        } finally {
            tracer.close(frameName)
        }
    }

import org.gradle.internal.serialize.Encoder;

import java.io.Closeable;
import java.io.IOException;

public interface BinaryStore {
    void write(WriteAction write);

    //done writing data, release any resources
    BinaryData done();

    interface WriteAction {
        void write(Encoder encoder) throws IOException;
    }

    interface ReadAction<T> {
        T read(Decoder decoder) throws IOException;
    }

            writer.write("    ");
        }
    }

    public void indent(WriteAction action) throws IOException {
        try {
            indent++;
            action.run();
        } finally {
            indent--;
        }
    }

    @FunctionalInterface
    interface WriteAction {
        void run() throws IOException;
    }

    }

    @Override
    public void writeNullableString(@Nullable CharSequence value) {
        output.writeString(value);
    }

    @Override
    public void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception {
        if (nested == null) {
            nested = new KryoBackedEncoder(new OutputStream() {
                @Override
                public void write(byte[] buffer, int offset, int length) {

class DummyBinaryStore implements BinaryStore {

    private final ByteArrayOutputStream bytes = new ByteArrayOutputStream()
    private Encoder output = new OutputStreamBackedEncoder(bytes)

    void write(WriteAction write) {
        write.write(output)
    }

    BinaryData done() {
        new BinaryData() {
            Decoder decoder
            def <T> T read(ReadAction<T> readAction) {

        writeSmallInt(count);
        writeBytes(bytes, offset, count);
    }

    @Override
    public void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    public void writeSmallInt(int value) throws IOException {
        writeInt(value);
    }

    @Override

    private StringDeduplicatingKryoBackedEncoder encoder;
    private long offset = -1;

    public DefaultBinaryStore(File file) {
        this.file = file;
    }

    @Override
    public void write(WriteAction write) {
        if (encoder == null) {
            try {
                encoder = new StringDeduplicatingKryoBackedEncoder(new FileOutputStream(file));
            } catch (FileNotFoundException e) {