ByteArrayDataOutput out = ByteStreams.newDataOutput();
    out.writeInt(0x12345678);
    out.writeInt(0x76543210);
    assertThat(out.toByteArray()).isEqualTo(bytes);
  }

  public void testNewDataOutput_sized() {
    ByteArrayDataOutput out = ByteStreams.newDataOutput(4);
    out.writeInt(0x12345678);
    out.writeInt(0x76543210);
    assertThat(out.toByteArray()).isEqualTo(bytes);
  }

        Class<?> targetClass = desc.forClass();
        writeClass(targetClass);
    }

    @Override
    protected void annotateProxyClass(Class<?> cl) throws IOException {
        writeInt(cl.getInterfaces().length);
        for (Class<?> type : cl.getInterfaces()) {
            writeClass(type);
        }
    }

    private void writeClass(Class<?> targetClass) throws IOException {

    }

    InputStream encoded(String text) {
        def stream = new ByteArrayOutputStream()
        def encoder = new KryoBackedEncoder(stream)
        encoder.writeString(text)
        encoder.writeInt(12)
        encoder.flush()
        return new ByteArrayInputStream(stream.toByteArray())
    }

  }

  @Test
  fun writeSingleByteInt() {
    hpackWriter!!.writeInt(10, 31, 0)
    assertBytes(10)
    hpackWriter!!.writeInt(10, 31, 0xe0)
    assertBytes(0xe0 or 10)
  }

  @Test
  fun writeMultibyteInt() {
    hpackWriter!!.writeInt(1337, 31, 0)
    assertBytes(31, 154, 10)
    hpackWriter!!.writeInt(1337, 31, 0xe0)
    assertBytes(0xe0 or 31, 154, 10)
  }

  @Test

            values.add(entrySerializer.read(decoder));
        }
        return values;
    }

    @Override
    public void write(Encoder encoder, C value) throws Exception {
        encoder.writeInt(value.size());
        for (T t : value) {
            entrySerializer.write(encoder, t);
        }
    }

    }

    static class InefficientSerializer implements Serializer<Long> {
        @Override
        void write(Encoder encoder, Long value) throws Exception {
            value.times { int n ->
                encoder.writeInt(n)
            }
        }

        @Override
        Long read(Decoder decoder) throws EOFException, Exception {
            throw new UnsupportedOperationException()
        }
    }

        UUID canonicalAddress = address.getCanonicalAddress();
        encoder.writeLong(canonicalAddress.getMostSignificantBits());
        encoder.writeLong(canonicalAddress.getLeastSignificantBits());
        encoder.writeInt(address.getPort());
        encoder.writeSmallInt(address.getCandidates().size());
        for (InetAddress inetAddress : address.getCandidates()) {
            encoder.writeBinary(inetAddress.getAddress());
        }
    }

            }
        }

        private void writeStopEvents(Encoder encoder, DaemonRegistryContent registry) throws Exception {
            List<DaemonStopEvent> stopEvents = registry.stopEvents;
            encoder.writeInt(stopEvents.size());
            for (DaemonStopEvent stopEvent : stopEvents) {
                DaemonStopEvent.SERIALIZER.write(encoder, stopEvent);
            }
        }

            encoder.writeByte(MIXIN_CLASSLOADER_SPEC);
        } else {
            encoder.writeByte(VISITABLE_URL_CLASSLOADER_SPEC);
        }

        encoder.writeString(spec.getName());
        encoder.writeInt(spec.getClasspath().size());
        for (URL url : spec.getClasspath()) {
            encoder.writeString(url.toString());
        }
    }

    @Override

            valueMap.put(key, value);
        }
        return valueMap;
    }

    @Override
    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }