fillReq:   make(chan struct{}),
		fillReady: make(chan int64),
	}

	go func() {
		var rpos int64 // total bytes read into buffer

		defer func() {
			atomic.StoreInt64(&sr.end, rpos)
			close(sr.fillReady)
		}()

		for range sr.fillReq {
		scan:
			n, err := r.Read(sr.nbuf[:])

			if n == 0 {
				switch err {
				case io.EOF: // reader is exhausted
					return

        CliRequest request = new CliRequest(new String[] {"-T", "5"}, null);

        cli.initialize(request);
        // read .mvn/maven.config
        cli.cli(request);

        assertEquals("5", request.commandLine.getOptionValue(CLIManager.THREADS));
    }

    /**
     * Read .mvn/maven.config with the following definitions:
     * <pre>
     *   -T
     *   3
     *   -Drevision=1.3.0

Stellen Sie Ihre App jetzt mit **einem einzigen Befehl** bereit:

<div class="termy">

```console
$ fastapi deploy

Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
```

</div>

Das war’s! Jetzt können Sie Ihre App unter dieser URL aufrufen. ✨

## Über FastAPI Cloud { #about-fastapi-cloud }

And it's possible that for your use case, the solution is in one of them.

///

## Read the Tutorial first { #read-the-tutorial-first }

You could still use most of the features in **FastAPI** with the knowledge from the main [Tutorial - User Guide](../tutorial/index.md).

        trans2FindNext2 = new Trans2FindNext2(config, TEST_SID, TEST_RESUME_KEY, TEST_FILENAME, TEST_BATCH_COUNT, TEST_BATCH_SIZE);

        byte[] buffer = new byte[10];
        int read = trans2FindNext2.readSetupWireFormat(buffer, 0, 10);

        assertEquals(0, read);
    }

    @Test
    void testReadParametersWireFormat() {
        // Test parameters wire format reading (should return 0)

        trans2QueryPathInfo = new Trans2QueryPathInformation(config, TEST_FILENAME, TEST_INFO_LEVEL);

        byte[] buffer = new byte[256];
        int read = trans2QueryPathInfo.readSetupWireFormat(buffer, 0, buffer.length);

        // Should read nothing (returns 0)
        assertEquals(0, read);
    }

    @Test
    void testReadParametersWireFormat() {

    stream = io.BytesIO(b"data")
    file = UploadFile(filename="file", file=stream, size=4)
    assert await file.read() == b"data"
    assert file.size == 4
    await file.write(b" and more data!")
    assert await file.read() == b""
    assert file.size == 19
    await file.seek(0)
    assert await file.read() == b"data and more data!"

    /**
     * Lock and read operation is supported capability.
     */
    int CAP_LOCK_AND_READ = 0x0100;
    /**
     * NT find operations are supported capability.
     */
    int CAP_NT_FIND = 0x0200;
    /**
     * DFS operations are supported capability.
     */
    int CAP_DFS = 0x1000;
    /**
     * Large read operations are supported capability.
     */

) {
  private val countingSource: CountingSource = CountingSource(source)
  private val source: BufferedSource = countingSource.buffer()

  /** Total bytes read thus far. */
  private val byteCount: Long
    get() = countingSource.bytesRead - source.buffer.size

  /** How many bytes to read before [peekHeader] should return false, or -1L for no limit. */
  private var limit = -1L

                throw new PACDecodingException("Not a kerberos token");
            }

            int readLow = stream.read() & 0xff;
            int readHigh = stream.read() & 0xff;
            int read = (readHigh << 8) + readLow;
            if (read != 0x01) {
                throw new PACDecodingException("Malformed kerberos token");
            }