}
}

type teststringwriter struct {
	write       string
	writeString string
}

func (w *teststringwriter) Write(b []byte) (int, error) {
	w.write += string(b)
	return len(b), nil
}

func (w *teststringwriter) WriteString(s string) (int, error) {
	w.writeString += s
	return len(s), nil
}

func (w *teststringwriter) check(t *testing.T, write, writeString string) {
	t.Helper()

	hdr := &FileHeader{Name: "."}
	hdr.SetMode(fs.ModeDir | 0o755)
	w, err := zw.CreateHeader(hdr)
	if err != nil {
		t.Fatalf("create zip header: %v", err)
	}
	_, err = w.Write([]byte("some data"))
	if err != nil {
		t.Fatalf("write zip contents: %v", err)

	}
	err = zw.Close()
	if err != nil {
		t.Fatalf("close zip writer: %v", err)

	}

        if (log.isTraceEnabled()) {
            log.trace(req.toString());
            log.trace(Hexdump.toHexString(this.sbuf, 4, n));
        }

        this.out.write(this.sbuf, 0, 4 + n);
        this.out.flush();
        log.trace("Wrote negotiate request");
        return n;
    }

    /**
     * @throws SocketException
     * @throws IOException
     */

		// Fan-out requires no copying, and must be carried from original source
		// https://en.wikipedia.org/wiki/Copy_protection so the incoming stream
		// is always going to be in-memory as we cannot re-read from what we
		// wrote to disk - since that amounts to "copying" from a "copy"
		// instead of "copying" from source, we need the stream to be seekable
		// to ensure that we can make fan-out calls concurrently.
		buf := bytebufferpool.Get()

	// 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"

    val dataLength = 16384
    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK
    peer.acceptFrame() // SYN_STREAM
    peer.sendFrame().headers(false, 3, headerEntries("b", "banana"))
    peer.sendFrame().data(false, 3, Buffer().write(ByteArray(dataLength)), dataLength)
    peer.sendFrame().data(false, 3, Buffer().write(ByteArray(dataLength)), dataLength)

   * segments, each governed by its own write lock. The segment lock is taken once for each explicit
   * write, and twice for each cache loading computation (once prior to loading the new value, and
   * once after loading completes). Much internal cache management is performed at the segment
   * granularity. For example, access queues and write queues are kept per segment when they are

        String newContent = "New content\n";

        // Write initial content
        try (OutputStream out = file.openOutputStream(false)) {
            out.write(initialContent.getBytes("UTF-8"));
        }

        // Overwrite with new content
        try (OutputStream out = file.openOutputStream(false)) {
            out.write(newContent.getBytes("UTF-8"));
        }

        // Verify new content

	if err != nil {
		return
	}
	if (zb0001Mask & 0x1) == 0 { // if not omitted
		// write "V2Obj"
		err = en.Append(0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
		if err != nil {
			return
		}
		if z.ObjectV2 == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			// map header, size 1
			// write "DDir"
			err = en.Append(0x81, 0xa4, 0x44, 0x44, 0x69, 0x72)
			if err != nil {

func (z *BucketReplicationResyncStatus) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "v"
	err = en.Append(0x84, 0xa1, 0x76)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Version)
	if err != nil {
		err = msgp.WrapError(err, "Version")
		return
	}
	// write "brs"
	err = en.Append(0xa3, 0x62, 0x72, 0x73)
	if err != nil {
		return
	}