import okio.Buffer
import okio.ForwardingTimeout
import okio.Sink
import okio.Source
import okio.Timeout

/**
 * A socket connection that can be used to send HTTP/1.1 messages. This class strictly enforces the
 * following lifecycle:
 *
 *  1. [Send request headers][writeRequest].
 *  2. Open a sink to write the request body. Either [known][newKnownLengthSink] or
 *     [chunked][newChunkedSink].

                        Smb2LeaseState.SMB2_LEASE_NONE, false);
                }
                
                // Send create request
                Smb2CreateResponse response = (Smb2CreateResponse) 
                    file.getTree().send(createReq);
                
                if (response.isSuccess()) {
                    // Update file with new handle

import org.codelibs.fess.timer.SystemMonitorTarget;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.SystemUtil;
import org.codelibs.fess.util.ThreadDumpUtil;
import org.dbflute.mail.send.hook.SMailCallbackContext;
import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;
import org.lastaflute.core.mail.Postbox;

///

## About HTTP status codes { #about-http-status-codes }

/// note

If you already know what HTTP status codes are, skip to the next section.

///

In HTTP, you send a numeric status code of 3 digits as part of the response.

These status codes have a name associated to recognize them, but the important part is the number.

In short:

	for {
		select {
		case hi, hasMore := <-healthInfoCh:
			if !hasMore {
				auditOptions := AuditLogOptions{Event: "callhome:diagnostics"}
				// Received all data. Send to SUBNET and return
				err := sendHealthInfo(ctx, healthInfo)
				if err != nil {
					internalLogIf(ctx, fmt.Errorf("Unable to perform callhome: %w", err))
					auditOptions.Error = err.Error()
				}

        if (this.handle.isStale()) {
            throw new IOException("DCERPC pipe is no longer open");
        }
        this.handle.send(buf, off, length);
    }

    @Override
    protected int doReceiveFragment(final byte[] buf) throws IOException {
        if (buf.length < getMaxRecv()) {

            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                connection.setRequestProperty(authProperty, authMethod + ' ' + Base64.encode(type1.toByteArray()));
                connection.connect(); // send type 1
                response = parseResponseCode();
                if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {
                    return;
                }

        if (requestHeaders.name(i) == Header.TARGET_PATH_UTF8) {
          path = requestHeaders.value(i)
          break
        }
        i++
      }
      if (path == null) {
        // TODO: send bad request error
        throw AssertionError()
      }
      val file = File(baseDirectory.toString() + path)
      if (file.isDirectory) {
        serveDirectory(stream, file.listFiles()!!)

			fd := int(fdPtr)

			_ = unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)

			_ = unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)

			// Enable custom socket send/recv buffers.
			if opts.SendBufSize > 0 {
				_ = unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_SNDBUF, opts.SendBufSize)
			}

			if opts.RecvBufSize > 0 {

/// tip

Note that the test function is now `async def` instead of just `def` as before when using the `TestClient`.

///

Then we can create an `AsyncClient` with the app, and send async requests to it, using `await`.

{* ../../docs_src/async_tests/app_a_py39/test_main.py hl[9:12] *}

This is the equivalent to:

```Python
response = client.get('/')
```