/**
     * Method write.
     *
     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    @Override
    public void write(Writer writer, Model model) throws IOException {
        super.write(writer, model);
    } // -- void write( Writer, Model )

    /**
     * Method write.
     *
     * @param stream a stream object.

        delegate.setFileComment(fileComment);
    }

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param settings a settings object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Settings settings) throws IOException {
        try {
            delegate.write(writer, settings.getDelegate());
        } catch (XMLStreamException e) {

    }

    private void writeLittleEndianInt(DataOutputStream dos, int value) throws IOException {
        dos.writeInt(Integer.reverseBytes(value));
    }

    private void writeLittleEndianLong(DataOutputStream dos, long value) throws IOException {
        dos.writeLong(Long.reverseBytes(value));
    }

    @Test
    @DisplayName("Test parsing with invalid data size")
    void testInvalidDataSize() {

    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(
          Buffer().writeLong(0L).writeLong(it).readByteArray(),
        )
      }
  }

        Request
          .Builder()
          .url(server.url("/"))
          .post(
            object : RequestBody() {
              override fun contentType() = null

              override fun writeTo(sink: BufferedSink) {
                for (i in 0..9) {
                  sink.writeByte(0)
                  sink.flush()
                  sleep(100)
                }

In OkHttp we expose a blocking API over a framed protocol. This document explains the code and policy that makes that work.

### Threads

#### Application's calling thread

                    logger.fine(() -> ">>> " + body);
                    connection.setDoOutput(true);
                    try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), encoding))) {
                        writer.write(body);
                        writer.flush();
                    }
                } else if (bodyStream != null) {
                    logger.fine(() -> ">>> <binary>");

        }
    }

    protected void write(Model model, Path dest) throws IOException, XMLStreamException {
        String version = model.getModelVersion();
        Files.createDirectories(dest.getParent());
        try (Writer w = Files.newBufferedWriter(dest)) {
            MavenStaxWriter writer = new MavenStaxWriter();
            writer.setNamespace(String.format(NAMESPACE_FORMAT, version));

        int pos = 8; // Position where content should be written
        int off = 0; // Offset where position should be written

        // Test with non-null source array
        int bytesWritten = NtlmMessage.writeSecurityBufferContent(dest, pos, off, src);
        assertEquals(src.length, bytesWritten, "Should return correct number of bytes written.");

        byte[] buffer = new byte[1024];

        int written = request.writeBytesWireFormat(buffer, 0);

        // Should write exactly 56 bytes (structure size without data)
        assertEquals(56, written);
        // Check structure size (first 2 bytes should be 57)
        assertEquals(57, (buffer[0] & 0xFF) | ((buffer[1] & 0xFF) << 8));
    }