/**
     * Implementation method for writing an XML node to a writer.
     *
     * @param node the XML node to write
     * @param writer the writer to write to
     * @throws IOException if there is an error writing the XML
     */
    protected abstract void doWrite(XmlNode node, Writer writer) throws IOException;

    /**
     * Implementation method for merging two XML nodes.
     *

    // Use a new Writer because we don't support change the dynamic table
    // size after Writer constructed.
    val writer = Hpack.Writer(110, false, bytesOut)
    writer.writeHeaders(headerBlock)
    assertThat(bytesOut).isEqualTo(bytesIn)
    assertThat(writer.headerCount).isEqualTo(2)
    val tableLength = writer.dynamicTable.size
    var entry = writer.dynamicTable[tableLength - 1]!!

          Huffman.encode(data, huffmanBuffer)
          val huffmanBytes = huffmanBuffer.readByteString()
          writeInt(huffmanBytes.size, PREFIX_7_BITS, 0x80)
          out.write(huffmanBytes)
        } else {
          writeInt(data.size, PREFIX_7_BITS, 0)
          out.write(data)
        }
      }

      fun resizeHeaderTable(headerTableSizeSetting: Int) {

	dw, err := w.Create("dir/")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := dw.Write(nil); err != nil {
		t.Errorf("Write(nil) to directory: got %v, want nil", err)
	}
	if _, err := dw.Write([]byte("hello")); err == nil {
		t.Error(`Write("hello") to directory: got nil error, want non-nil`)
	}
}

func TestWriterDirAttributes(t *testing.T) {
	var buf bytes.Buffer
	w := NewWriter(&buf)

     * @return number of bytes written
     */
    protected abstract int writeParametersWireFormat(byte[] dst, int dstIndex);

    /**
     * Writes data in wire format
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     * @return number of bytes written
     */
    protected abstract int writeDataWireFormat(byte[] dst, int dstIndex);

		b = append(b, ' ')
		w.Write(b)
	}
	w.Flush()
	// Output: 1 2 3 4
}

// ExampleWriter_ReadFrom demonstrates how to use the ReadFrom method of Writer.
func ExampleWriter_ReadFrom() {
	var buf bytes.Buffer
	writer := bufio.NewWriter(&buf)

	data := "Hello, world!\nThis is a ReadFrom example."
	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {

        byte[] minBuffer = new byte[2];
        int written = trans2QueryFSInfo.writeSetupWireFormat(minBuffer, 0);
        assertEquals(2, written);

        // Test with exact parameter size
        byte[] paramBuffer = new byte[2];
        written = trans2QueryFSInfo.writeParametersWireFormat(paramBuffer, 0);
        assertEquals(2, written);

        // Test with zero-length data buffer

}

// EncodeMsg implements msgp.Encodable
func (z BatchJobExpirePurge) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "RetainVersions"
	err = en.Append(0x81, 0xae, 0x52, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.RetainVersions)
	if err != nil {
		err = msgp.WrapError(err, "RetainVersions")
		return
	}

  private val messageBuffer = Buffer()

  /** The [Buffer] of [sink]. Write to this and then flush/emit [sink]. */
  private val sinkBuffer: Buffer = sink.buffer
  private var writerClosed = false

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null

        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")
    void writeBytesWireFormat_throwsIfInsufficientSpace() {
        // Arrange