func (z BatchJobRetry) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Attempts"
	err = en.Append(0x82, 0xa8, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Attempts)
	if err != nil {
		err = msgp.WrapError(err, "Attempts")
		return
	}
	// write "Delay"
	err = en.Append(0xa5, 0x44, 0x65, 0x6c, 0x61, 0x79)

    }

    return result
  }

  override fun toDer(
    writer: DerWriter,
    value: T,
  ) {
    if (typeHint) {
      writer.typeHint = value
    }

    if (isOptional && value == defaultValue) {
      // Nothing to write!
      return
    }

    writer.write(name, tagClass, tag) {
      codec.encode(writer, value)
    }
  }

  /**

        // Fill buffer with non-zero values to ensure padding writes zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        int written = trans2SetFileInfo.writeDataWireFormat(buffer, 0);

        // Should report 26 bytes written (20 from encode + 6 increment)
        assertEquals(26, written);

        // Check that padding bytes are zeros

  fun fromDer(byteString: ByteString): T {
    val buffer = Buffer().write(byteString)
    val reader = DerReader(buffer)
    return fromDer(reader)
  }

  /**
   * Writes [value] to this adapter, unless it is the default value and can be safely omitted.
   *
   * If this does write a value, it will write a tag and a length and a full value.
   */
  fun toDer(
    writer: DerWriter,
    value: T,
  )

      }
      if (associatedStreamId == 0) {
        writer.headers(outFinished, streamId, requestHeaders)
      } else {
        require(!client) { "client streams shouldn't have associated stream IDs" }
        // HTTP/2 has a PUSH_PROMISE frame.
        writer.pushPromise(associatedStreamId, streamId, requestHeaders)
      }
    }

    if (flushHeaders) {
      writer.flush()
    }

    return stream
  }

	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)

    }

    @Test
    @DisplayName("writeSetupWireFormat writes the subCommand and a trailing 0")
    void testWriteSetupWireFormat() {
        Trans2QueryFSInformation cmd = new Trans2QueryFSInformation(5);
        byte[] buf = newBuffer(10);
        int written = cmd.writeSetupWireFormat(buf, 0);
        assertEquals(2, written, "setup packet should write 2 bytes");

          Huffman.encode(data, huffmanBuffer)
          val huffmanBytes = huffmanBuffer.readByteString()
          writeInt(huffmanBytes.size, PREFIX_7_BITS, 0x80)
          out.write(huffmanBytes)
        } else {
          writeInt(data.size, PREFIX_7_BITS, 0)
          out.write(data)
        }
      }

      fun resizeHeaderTable(headerTableSizeSetting: Int) {

    public CharSink createSink() throws IOException {
      File file = createFile();
      if (initialString != null) {
        Writer writer = new OutputStreamWriter(new FileOutputStream(file), UTF_8);
        try {
          writer.write(initialString);
        } finally {
          writer.close();
        }
        return Files.asCharSink(file, UTF_8, FileWriteMode.APPEND);
      }

      failed = true

      socketToCancel = this.socket

      writerToClose = this.writer
      this.writer = null

      if (!isWriter && writerToClose != null) {
        // If the caller isn't the writer thread, get that thread to close the writer.
        taskQueue.execute("$name writer close", cancelable = false) {
          writerToClose.closeQuietly()
        }
      }