* for the specified servlet request.
     *
     * @param tc the CIFS context to use
     *
     * @param req
     *            The request being serviced.
     * @param resp
     *            The response.
     * @param challenge
     *            The domain controller challenge.
     * @return credentials passed in the servlet request
     * @throws IOException

  }

  @Test
  fun request() {
    val request: Request = Request.Builder().build()
    val isHttps: Boolean = request.isHttps
    val url: HttpUrl = request.url
    val method: String = request.method
    val headers: Headers = request.headers
    val header: String? = request.header("")
    val headersForName: List<String> = request.headers("")
    val body: RequestBody? = request.body

    }

    /**
     * Set the create contexts for this request
     * @param contexts the create contexts to set
     */
    public void setCreateContexts(CreateContextRequest[] contexts) {
        this.createContexts = contexts;
    }

    /**
     * Add a create context to this request
     * @param context the create context to add
     */

      MockResponse
        .Builder()
        .status("HTTP/1.1 200 ${"O".repeat(256 * 1024)}K")
        .body("I'm not even supposed to be here today.")
        .build(),
    )
    val call = client.newCall(Request(url = server.url("/")))
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  /** Use a header that exceeds the limits on its own. */
  @Test
  fun largeResponseHeader() {
    server.enqueue(

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).

    }

    /**
     * Returns true if the request contains conditions that save the server from sending a response
     * that the client has locally. When a request is enqueued with its own conditions, the built-in
     * response cache won't be used.
     */
    private fun hasConditions(request: Request): Boolean =
      request.header("If-Modified-Since") != null || request.header("If-None-Match") != null
  }

         * direct dependencies from the request will be merged with the direct dependencies from the root dependency's
         * artifact descriptor, giving higher priority to the dependencies from the request.
         *
         * @param dependencies the direct dependencies, may be {@code null}
         * @return this request for chaining, never {@code null}
         */

    """
    A file uploaded in a request.

    Define it as a *path operation function* (or dependency) parameter.

    If you are using a regular `def` function, you can use the `upload_file.file`
    attribute to access the raw standard Python file (blocking, not async), useful and
    needed for non-async code.

    Read more about it in the

 */

package jcifs.smb1.netbios;

import java.io.IOException;
import java.io.InputStream;

/**
 * NetBIOS session request packet for establishing sessions.
 * This packet is sent to request a NetBIOS session with a remote host.
 */
public class SessionRequestPacket extends SessionServicePacket {

    private final Name calledName, callingName;

    SessionRequestPacket() {

            // Initial setup
            request.setData(new byte[100], 0, 100);
            request.setOffset(1000L);
            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            // Update parameters
            request.setData(new byte[200], 0, 200);
            request.setOffset(2000L);
            request.setRemainingBytes(1000);
            request.setWriteFlags(0x02);