if err != nil {
		err = msgp.WrapError(err, "PoolIndex")
		return
	}
	// write "Queued"
	err = en.Append(0xa6, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64)
	if err != nil {
		return
	}
	err = en.WriteTime(z.Queued)
	if err != nil {
		err = msgp.WrapError(err, "Queued")
		return
	}
	// write "BitrotScan"
	err = en.Append(0xaa, 0x42, 0x69, 0x74, 0x72, 0x6f, 0x74, 0x53, 0x63, 0x61, 0x6e)
	if err != nil {

     * @param t the time value in milliseconds since January 1, 1970 UTC
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     */
    public static void writeTime(long t, final byte[] dst, final int dstIndex) {
        if (t != 0L) {
            t = (t + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;
        }
        writeInt8(t, dst, dstIndex);
    }

        buffer[bufferIndex++] = 0;
        buffer[bufferIndex++] = 0;
        buffer[bufferIndex++] = 0;
        // serverTime
        long time = new Date().getTime();
        SMBUtil.writeTime(time, buffer, bufferIndex);
        bufferIndex += 8;
        // serverTimeZone
        buffer[bufferIndex++] = (byte) 0x80;
        buffer[bufferIndex++] = (byte) 0xFF;
        // encryptionKeyLength

    Arrays.fill(data, (byte)0x42);
    
    long start = System.currentTimeMillis();
    
    try (OutputStream os = file.getOutputStream()) {
        os.write(data);
    }
    
    long writeTime = System.currentTimeMillis() - start;
    
    // Read back
    start = System.currentTimeMillis();
    byte[] readData = new byte[data.length];
    
    try (InputStream is = file.getInputStream()) {

	rfw := &readFromWriter{}
	w := NewWriterSize(rfw, bufsize)

	const writeSize = 8
	if n, err := w.Write(input[:writeSize]); n != writeSize || err != nil {
		t.Errorf("w.Write(%v bytes) = %v, %v; want %v, nil", writeSize, n, err, writeSize)
	}
	n, err := w.ReadFrom(bytes.NewReader(input[writeSize:]))
	if wantn := len(input[writeSize:]); int(n) != wantn || err != nil {

        // Decode
        FileBasicInfo decoded = new FileBasicInfo();
        decoded.decode(buffer, 0, 36); // decode reads 36 bytes

        // Note: When encoding time 0, SMBUtil.writeTime writes 0 directly,
        // but SMBUtil.readTime interprets 0 as Jan 1, 1601 in Unix time (-11644473600000)
        // This is the expected behavior for Windows FILETIME

	if err != nil {
		return
	}
	err = en.WriteTime(z.Started)
	if err != nil {
		err = msgp.WrapError(err, "Started")
		return
	}
	// write "LastUpdate"
	err = en.Append(0xaa, 0x4c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65)
	if err != nil {
		return
	}
	err = en.WriteTime(z.LastUpdate)
	if err != nil {
		err = msgp.WrapError(err, "LastUpdate")
		return

	if err != nil {
		return
	}
	err = en.WriteTime(z.CreatedAfter)
	if err != nil {
		err = msgp.WrapError(err, "CreatedAfter")
		return
	}
	// write "CreatedBefore"
	err = en.Append(0xad, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65)
	if err != nil {
		return
	}
	err = en.WriteTime(z.CreatedBefore)
	if err != nil {

        final int hi = readInt4(src, srcIndex + 4);
        final long t = (long) hi << 32L | low & 0xFFFFFFFFL;
        return t / 10000L - MILLISECONDS_BETWEEN_1970_AND_1601;
    }

    static void writeTime(long t, final byte[] dst, final int dstIndex) {
        if (t != 0L) {
            t = (t + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;
        }
        writeInt8(t, dst, dstIndex);
    }

  }

  private fun upload(
    chunked: Boolean,
    size: Int,
    writeSize: Int,
  ) {
    server.enqueue(MockResponse())
    executeSynchronously(
      Request(
        url = server.url("/"),
        body = requestBody(chunked, size.toLong(), writeSize),
      ),
    )
  }

  /** https://github.com/square/okhttp/issues/2344  */
  @Test