}
	for i := 0; i < chunks; i++ {
		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")
	_, err = f.Write(end)
	if err != nil {
		t.Fatal("write end:", err)
	}
	if err := w.Close(); err != nil {

	if lri, reply = l.lockMap[resource]; !reply {
		// No lock is held on the given name
		return true, nil
	}
	if isWriteLock(lri) {
		// A write-lock is held, cannot release a read lock
		return false, fmt.Errorf("RUnlock attempted on a write locked entity: %s", resource)
	}
	l.removeEntry(resource, args, &lri)
	return reply, nil
}

type lockStats struct {
	Total          int

  fun connectionPreface() {
    withLock {
      if (closed) throw IOException("closed")
      if (!client) return // Nothing to write; servers don't send connection headers!
      if (logger.isLoggable(FINE)) {
        logger.fine(format(">> CONNECTION ${CONNECTION_PREFACE.hex()}"))
      }
      sink.write(CONNECTION_PREFACE)
      sink.flush()
    }
  }

  /** Applies `peerSettings` and then sends a settings ACK. */

        setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

        // Write notification data at buffer offset 80
        int notifyOffset = 80;

 */
class PacSignatureTest {

    /**
     * Helper method to write integer in little-endian format.
     */
    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putInt(value);
        baos.write(buffer.array(), 0, 4);
    }

    /**

	writeQuorum int
	errs        []error
}

// Write writes data to writers.
func (p *multiWriter) Write(ctx context.Context, blocks [][]byte) error {
	for i := range p.writers {
		if p.errs[i] != nil {
			continue
		}
		if p.writers[i] == nil {
			p.errs[i] = errDiskNotFound
			continue
		}
		var n int
		n, p.errs[i] = p.writers[i].Write(blocks[i])
		if p.errs[i] == nil {
			if n != len(blocks[i]) {

     *
     * @param val the integer value to convert to hexadecimal characters
     * @param dst the destination character array to write the hex digits into
     * @param dstIndex the starting index in the destination array
     * @param size the number of hex digits to write (will be left-padded with zeros)
     */
    public static void toHexChars(int val, final char dst[], final int dstIndex, int size) {

func (z *CheckPartsHandlerParams) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "id"
	err = en.Append(0x84, 0xa2, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteString(z.DiskID)
	if err != nil {
		err = msgp.WrapError(err, "DiskID")
		return
	}
	// write "v"
	err = en.Append(0xa1, 0x76)
	if err != nil {
		return
	}
	err = en.WriteString(z.Volume)

    int getAttributes();

    /**
     * Gets the file creation time.
     *
     * @return file create time
     */
    long getCreateTime();

    /**
     * Gets the file last write time.
     *
     * @return file last write time
     */
    long getLastWriteTime();

    /**
     * Gets the file last access time.
     *
     * @return file last access time
     */
    long getLastAccessTime();

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