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)

    @Throws(IOException::class)
    override fun writeTo(sink: BufferedSink) {
      val forwardingSink =
        object : ForwardingSink(sink) {
          private var totalBytesWritten: Long = 0
          private var completed = false

          override fun write(
            source: Buffer,
            byteCount: Long,
          ) {
            super.write(source, byteCount)
            totalBytesWritten += byteCount

// EncodeMsg implements msgp.Encodable
func (z BatchJobKeyRotateEncryption) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Type"
	err = en.Append(0x83, 0xa4, 0x54, 0x79, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(string(z.Type))
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	// write "Key"
	err = en.Append(0xa3, 0x4b, 0x65, 0x79)
	if err != nil {
		return
	}

                writeFesenCat(zos, diagnosticId);
                writeFesenJson(zos, diagnosticId);
            }
        });
    }

    /**
     * Writes OpenSearch JSON API responses to the ZIP output stream.
     *
     * @param zos the ZIP output stream to write to
     * @param id the diagnostic ID for organizing files in the ZIP
     */
    protected void writeFesenJson(final ZipOutputStream zos, final String id) {

    }

    // Helper method to write content to test file
    private void writeTestFile(String content) throws IOException {
        Writer writer = null;
        try {
            writer = new OutputStreamWriter(new FileOutputStream(testFile), Constants.UTF_8);
            writer.write(content);
            writer.flush();
        } finally {
            CloseableUtil.closeQuietly(writer);

    assertOnFileDescriptor(content = "Hello") { fd ->
      val requestBody = fd.toRequestBody()

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")

      assertThrows(IOException::class.java) {
        requestBody.writeTo(Buffer())
      }
    }
  }

  @Test
  fun testFileDescriptorAfterClose() {

}

// EncodeMsg implements msgp.Encodable
func (z RStat) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Count"
	err = en.Append(0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.Count)
	if err != nil {
		err = msgp.WrapError(err, "Count")
		return
	}
	// write "Bytes"
	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
	if err != nil {

	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 {

    @Override
    public long contentLength() throws IOException {
      return delegate.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
      BufferedSink bufferedSink = Okio.buffer(sink(sink));
      delegate.writeTo(bufferedSink);
      bufferedSink.flush();
    }

    public Sink sink(Sink sink) {
      return new ForwardingSink(sink) {

   *
   * 1. visibility of the writes to these fields to Fire.run:
   *
   * The initial write to delegateRef is made definitely visible via the semantics of
   * addListener/SES.schedule. The later racy write in cancel() is not guaranteed to be observed,
   * however that is fine since the correctness is based on the atomic state in our base class. The