val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8064".decodeHex()).write(bytes, 100, 100)
    clientReader.processNextFrame()
    callback.assertBinaryMessage(bytes)
  }

  @Test fun twoFrameNotContinuation() {
    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8264".decodeHex()).write(bytes, 100, 100)

  /*
   * Implemented by entries that use write order. Write entries are maintained in a doubly-linked
   * list. New entries are added at the tail of the list at write time and stale entries are
   * expired from the head of the list.
   */

  @SuppressWarnings("GoodTime")
  /** Returns the time that this entry was last written, in ns. */
  long getWriteTime();

  /** Sets the entry write time in ns. */

	// SkipDecommissioned set to 'true' if the call requires skipping the pool being decommissioned.
	// mainly set for certain WRITE operations.
	SkipDecommissioned bool
	// SkipRebalancing should be set to 'true' if the call should skip pools
	// participating in a rebalance operation. Typically set for 'write' operations.
	SkipRebalancing bool

#### GNU/Linux and macOS (regular user)

On Linux and macOS you can use `--user` to run the container as regular user.

> NOTE: make sure --user has write permission to *${HOME}/data* prior to using `--user`.

```sh
mkdir -p ${HOME}/data
docker run \
  -p 9000:9000 \
  -p 9001:9001 \
  --user $(id -u):$(id -g) \
  --name minio1 \

  private val path = mutableListOf<String>()

  /**
   * False unless we made a recursive call to [write] at the current stack frame. The explicit box
   * adapter can clear this to synthesize non-constructed values that are embedded in octet strings.
   */
  var constructed = false

  fun write(
    name: String,
    tagClass: Int,
    tag: Long,
    block: (BufferedSink) -> Unit,
  ) {

Being able to use asynchronous functions in your tests could be useful, for example, when you're querying your database asynchronously. Imagine you want to test sending requests to your FastAPI application and then verify that your backend successfully wrote the correct data in the database, while using an async database library.

`UploadFile` has the following `async` methods. They all call the corresponding file methods underneath (using the internal `SpooledTemporaryFile`).

* `write(data)`: Writes `data` (`str` or `bytes`) to the file.
* `read(size)`: Reads `size` (`int`) bytes/characters of the file.
* `seek(offset)`: Goes to the byte position `offset` (`int`) in the file.

		allDriveLabels...)
	driveWritesPerSecMD = NewGaugeMD(driveWritesPerSec,
		"Writes per second on a drive",
		allDriveLabels...)
	driveWritesKBPerSecMD = NewGaugeMD(driveWritesKBPerSec,
		"Kilobytes written per second on a drive",
		allDriveLabels...)
	driveWritesAwaitMD = NewGaugeMD(driveWritesAwait,
		"Average time for write requests served on a drive",
		allDriveLabels...)
	drivePercUtilMD = NewGaugeMD(drivePercUtil,

			healthy := erasureSetUpCount[poolIdx][setIdx].online >= poolWriteQuorums[poolIdx]
			if !healthy && !opts.NoLogging {
				storageLogIf(logger.SetReqInfo(ctx, reqInfo),
					fmt.Errorf("Write quorum could not be established on pool: %d, set: %d, expected write quorum: %d, drives-online: %d",
						poolIdx, setIdx, poolWriteQuorums[poolIdx], erasureSetUpCount[poolIdx][setIdx].online), logger.FatalKind)
			}

	if err != nil {
		return toStorageErr(err)
	}
	return toStorageErr(st.Results(func(in []byte) error {
		_, err := wr.Write(in)
		return err
	}))
}

// WalkDirHandler - remote caller to list files and folders in a requested directory path.
func (s *storageRESTServer) WalkDirHandler(ctx context.Context, payload []byte, _ <-chan []byte, out chan<- []byte) (gerr *grid.RemoteErr) {