public void writeBytes(byte[] bytes) throws IOException {
        writeBytes(bytes, 0, bytes.length);
    }

    @Override
    public void writeBinary(byte[] bytes) throws IOException {
        writeBinary(bytes, 0, bytes.length);
    }

    @Override
    public void writeBinary(byte[] bytes, int offset, int count) throws IOException {
        writeSmallInt(count);
        writeBytes(bytes, offset, count);
    }

        }
        throw new IllegalStateException("Unexpected key in cache: " + object.getClass());
    }

    @Override
    public void write(Encoder encoder, PGPPublicKey key) throws Exception {
        encoder.writeBinary(key.getEncoded());
    }

    }

    def "can encode and decode byte array"() {
        expect:
        def bytes = encode { Encoder encoder ->
            encoder.writeBinary([] as byte[])
            encoder.writeBinary([1, 2, 3, 4] as byte[])
            encoder.writeBinary([0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7] as byte[], 2, 3)
        }
        decode(bytes) { Decoder decoder ->
            assert decoder.readBinary() == [] as byte[]

        encoder.writeString(componentIdentifier.getModule());
        encoder.writeString(componentIdentifier.getVersion());
        encoder.writeString(artifactId.getFileName());
        encoder.writeBinary(moduleSource.getSha1().toByteArray());
    }

    @Override
    public MetadataFileSource decode(Decoder decoder) throws IOException {
        String group = decoder.readString();

     */
    void readBytes(byte[] buffer, int offset, int count) throws EOFException, IOException;

    /**
     * Reads a byte array. Can read any byte array written using {@link Encoder#writeBinary(byte[])} or {@link Encoder#writeBinary(byte[], int, int)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the byte array was fully read.
     */
    byte[] readBinary() throws EOFException, IOException;

    @Override
    public void encode(ModuleDescriptorHashModuleSource moduleSource, Encoder encoder) throws IOException {
        encoder.writeBinary(moduleSource.getDescriptorHash().toByteArray());
        encoder.writeBoolean(moduleSource.isChangingModule());
    }

    @Override
    public ModuleDescriptorHashModuleSource decode(Decoder decoder) throws IOException {

    /**
     * Writes the given byte array to the stream. Encodes the bytes and length information.
     */
    void writeBinary(byte[] bytes) throws IOException;

    /**
     * Writes the given byte array to the stream. Encodes the bytes and length information.
     */
    void writeBinary(byte[] bytes, int offset, int count) throws IOException;

    /**

        } else if (snapshot instanceof HashCodeSnapshot) {
            HashCodeSnapshot hashSnapshot = (HashCodeSnapshot) snapshot;
            encoder.writeSmallInt(HASH_SNAPSHOT);
            encoder.writeBinary(hashSnapshot.getValue().toByteArray());
        } else if (snapshot instanceof FileValueSnapshot) {
            FileValueSnapshot fileSnapshot = (FileValueSnapshot) snapshot;
            encoder.writeSmallInt(FILE_SNAPSHOT);

        javaSerializer.write(encoder, value.getHeader());
        encoder.writeSmallInt(value.getSerializedModel().size());
        for (byte[] bytes : value.getSerializedModel()) {
            encoder.writeBinary(bytes);
        }
    }

    @Override
    public SerializedPayload read(Decoder decoder) throws Exception {
        Object header = javaSerializer.read(decoder);
        int count = decoder.readSmallInt();

        encoder.writeInt(address.getPort());
        encoder.writeSmallInt(address.getCandidates().size());
        for (InetAddress inetAddress : address.getCandidates()) {
            encoder.writeBinary(inetAddress.getAddress());
        }
    }