return "", "", false
	}
	return name[:i], name[i+1:], true
}

// Write writes to the current file in the tar archive.
// Write returns the error [ErrWriteTooLong] if more than
// Header.Size bytes are written after [Writer.WriteHeader].
//
// Calling Write on special types like [TypeLink], [TypeSymlink], [TypeChar],

	err = en.Append(0xa3, 0x66, 0x6c, 0x64)
	if err != nil {
		return
	}
	err = en.WriteBool(z.Failed)
	if err != nil {
		err = msgp.WrapError(err, "Failed")
		return
	}
	// write "lbkt"
	err = en.Append(0xa4, 0x6c, 0x62, 0x6b, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Bucket)
	if err != nil {
		err = msgp.WrapError(err, "Bucket")
		return
	}
	// write "lobj"

        doNothing().when(raf).write(any(byte[].class), anyInt(), anyInt());
        doNothing().when(raf).writeShort(anyInt());

        raf.writeUTF("é"); // 2-byte UTF-8 char

        // size prefix should be 2, and then write called with len=2
        verify(raf).writeShort(eq(2));
        verify(raf).write(any(byte[].class), eq(0), eq(2));
    }

    @Test
    @DisplayName("write(byte[],off,0): returns without I/O")

    }

    @Override
    public void rdmaWrite(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException {
        // TCP fallback doesn't support real RDMA write
        throw new UnsupportedOperationException("RDMA write not supported by TCP fallback");
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {

  public void testWriteString() throws IOException {
    File temp = createTempFile();
    Files.write(I18N, temp, UTF_16LE);
    assertEquals(I18N, Files.toString(temp, UTF_16LE));
  }

  public void testWriteBytes() throws IOException {
    File temp = createTempFile();
    byte[] data = newPreFilledByteArray(2000);
    Files.write(data, temp);
    assertThat(Files.toByteArray(temp)).isEqualTo(data);

    int FILE_READ_ATTRIBUTES = 0x00000080; // 8
    /** File write attributes access right */
    int FILE_WRITE_ATTRIBUTES = 0x00000100; // 9
    /** Delete access right */
    int DELETE = 0x00010000; // 16
    /** Read control access right */
    int READ_CONTROL = 0x00020000; // 17
    /** Write DAC access right */
    int WRITE_DAC = 0x00040000; // 18
    /** Write owner access right */
    int WRITE_OWNER = 0x00080000; // 19

	// write "no"
	err = en.Append(0xa2, 0x6e, 0x6f)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.NumObjects)
	if err != nil {
		err = msgp.WrapError(err, "NumObjects")
		return
	}
	// write "nv"
	err = en.Append(0xa2, 0x6e, 0x76)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.NumVersions)
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return
	}
	// write "bs"

    /**
     * Writes data to the specified file path.
     *
     * @param path the file path to write to
     * @param data the data to write
     */
    protected void write(final String path, final byte[] data) {
        validateFilePath(path);
        LdiFileUtil.write(path, data);
    }

    /**
     * Validates the file path.
     *
     * @param path the file path to validate

    // Write the first headers frame.
    writeMedium(frame, (headerBlock.size / 2).toInt() + paddingLength + 1)
    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_PADDED)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeByte(paddingLength)
    frame.write(headerBlock, headerBlock.size / 2)
    frame.write(padding)

	lrwm := NewLRWMutex()

	// fmt.Println("Getting initial write lock")
	if !lrwm.GetLock(ctx, "", "", time.Second) {
		panic("Failed to acquire initial write lock")
	}

	go func() {
		time.Sleep(2 * time.Second)
		lrwm.Unlock()
		// fmt.Println("Initial write lock released, waiting...")
	}()

	// fmt.Println("Trying to acquire 2nd write lock, waiting...")
	locked = lrwm.GetLock(ctx, "", "", duration)