def "stores binary data"() {
        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)

        }
        return result;
    }

    @Override
    public void write(Encoder encoder, IntSet value) throws Exception {
        encoder.writeInt(value.size());
        IntIterator iterator = value.iterator();
        while(iterator.hasNext()) {
            encoder.writeInt(iterator.nextInt());
        }
    }

            // Multiple dynamic table size updates!
            writeInt(smallestHeaderTableSizeSetting, PREFIX_5_BITS, 0x20)
          }
          emitDynamicTableSizeUpdate = false
          smallestHeaderTableSizeSetting = Integer.MAX_VALUE
          writeInt(maxDynamicTableByteCount, PREFIX_5_BITS, 0x20)
        }

        for (i in 0 until headerBlock.size) {

    }

    @Override
    public void writeLong(long value) throws IOException {
        outputStream.writeLong(value);
    }

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

    @Override
    public void writeShort(short value) throws IOException {
        outputStream.writeShort(value);
    }

    @Override

            }
            encoder.writeBoolean(context.idleTimeout != null);
            if (context.idleTimeout != null) {
                encoder.writeInt(context.idleTimeout);
            }
            encoder.writeInt(context.daemonOpts.size());
            for (String daemonOpt : context.daemonOpts) {
                encoder.writeString(daemonOpt);
            }

            outstr.writeInt(sharedPackages.size());
            for (String str : sharedPackages) {
                outstr.writeUTF(str);
            }

            // Serialize the worker implementation classpath, this is consumed by GradleWorkerMain
            if (runAsModule || implementationModulePath == null) {
                outstr.writeInt(implementationClassPath.size());

            builder.add(readIsolatable(decoder));
        }
    }

    private void writeIsolatableSequence(Encoder encoder, Collection<Isolatable<?>> elements) throws Exception {
        encoder.writeInt(elements.size());
        for (Isolatable<?> isolatable : elements) {
            writeIsolatable(encoder, isolatable);
        }
    }

    private Object readState(Decoder decoder) throws Exception {

        given:
        def incompleteStream = new ByteArrayOutputStream()
        def dataOut = new DataOutputStream(new EncodedStream.EncodedOutput(incompleteStream))
        dataOut.writeInt(1) // expect one classpath entry
        dataOut.write(1234) // but the entry is not a complete UTF-8 encoded String

        System.in = new ByteArrayInputStream(incompleteStream.toByteArray())

        when:

            outputStream.writeLong(nextBlock.getPos());
            outputStream.writeInt(largestInNextBlock);
            outputStream.writeInt(entries.size());
            for (FreeListEntry entry : entries) {
                outputStream.writeLong(entry.pos.getPos());
                outputStream.writeInt(entry.size);
            }
        }

        public void add(BlockPointer pos, int size) {

	if err != nil {
		err = msgp.WrapError(err, "DeadlineMS")
		return
	}
	err = en.WriteUint8(uint8(z.Handler))
	if err != nil {
		err = msgp.WrapError(err, "Handler")
		return
	}
	err = en.WriteUint8(uint8(z.Op))
	if err != nil {
		err = msgp.WrapError(err, "Op")
		return
	}
	err = en.WriteUint8(uint8(z.Flags))
	if err != nil {
		err = msgp.WrapError(err, "Flags")
		return
	}