private val path = mutableListOf<String>()

  /**
   * False unless we made a recursive call to [write] at the current stack frame. The explicit box
   * adapter can clear this to synthesize non-constructed values that are embedded in octet strings.
   */
  var constructed = false

  fun write(
    name: String,
    tagClass: Int,
    tag: Long,
    block: (BufferedSink) -> Unit,
  ) {

func (z *PoolDecommissionInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 16
	// write "st"
	err = en.Append(0xde, 0x0, 0x10, 0xa2, 0x73, 0x74)
	if err != nil {
		return
	}
	err = en.WriteTime(z.StartTime)
	if err != nil {
		err = msgp.WrapError(err, "StartTime")
		return
	}
	// write "ss"
	err = en.Append(0xa2, 0x73, 0x73)
	if err != nil {
		return
	}

	// map header, size 14
	// write "ReplicatedSize"
	err = en.Append(0x8e, 0xae, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x53, 0x69, 0x7a, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.ReplicatedSize)
	if err != nil {
		err = msgp.WrapError(err, "ReplicatedSize")
		return
	}
	// write "ReplicaSize"

func (z *lockRequesterInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 9
	// write "Name"
	err = en.Append(0x89, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "Writer"
	err = en.Append(0xa6, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72)
	if err != nil {
		return
	}

    default void write(@Nonnull T content, @Nonnull Path path) throws XmlWriterException {
        write(XmlWriterRequest.<T>builder().content(content).path(path).build());
    }

    default void write(@Nonnull T content, @Nonnull OutputStream outputStream) throws XmlWriterException {
        write(XmlWriterRequest.<T>builder()
                .content(content)

		return
	}
	// write "Name"
	err = en.Append(0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "Purge"
	err = en.Append(0xa5, 0x50, 0x75, 0x72, 0x67, 0x65)
	if err != nil {
		return
	}
	// map header, size 1
	// write "RetainVersions"

   */

  @Override
  public void write(int c) throws IOException {
    checkNotClosed();
    target.append((char) c);
  }

  @Override
  public void write(String str) throws IOException {
    checkNotNull(str);
    checkNotClosed();
    target.append(str);
  }

  @Override
  public void write(String str, int off, int len) throws IOException {
    checkNotNull(str);

        File lmhostsFile = tempDir.resolve("lmhosts_empty").toFile();
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.100 HOST1\n");
            writer.write("\n");
            writer.write("   \n");
            writer.write("192.168.1.101 HOST2\n");
        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());

      )
    val bufferA = Buffer()
    val bufferB = Buffer()
    bufferA.writeUtf8("Dodgson!\n")
    operatorA.write(0, bufferA, 9)
    bufferB.writeUtf8("You shouldn't use my name.\n")
    operatorB.write(9, bufferB, 27)
    bufferA.writeUtf8("Dodgson, we've got Dodgson here!\n")
    operatorA.write(36, bufferA, 33)
    operatorB.read(0, bufferB, 9)
    assertThat(bufferB.readUtf8()).isEqualTo("Dodgson!\n")

    @Override
    public void write(int c) {}

    @Override
    public void write(char[] cbuf) {
      checkNotNull(cbuf);
    }

    @Override
    public void write(char[] cbuf, int off, int len) {
      checkPositionIndexes(off, off + len, cbuf.length);
    }

    @Override
    public void write(String str) {
      checkNotNull(str);
    }

    @Override