Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = requestBody,
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      println(response.body.string())
    }
  }

  companion object {
    val MEDIA_TYPE_MARKDOWN = "text/x-markdown; charset=utf-8".toMediaType()
  }
}

fun main() {

def test_text_get():
    response = client.get("/text")
    assert response.status_code == 200, response.text
    assert response.json() == "Hello World"


def test_nonexistent():
    response = client.get("/nonexistent")
    assert response.status_code == 404, response.text
    assert response.json() == {"detail": "Not Found"}


def test_path_foobar():
    response = client.get("/path/foobar")

 */

package jcifs.internal.smb1.trans;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;

/**
 * Response for SMB1 TRANS_CALL_NAMED_PIPE transaction.
 *
 * This response contains the data returned from the named pipe
 * after a call transaction has been processed by the server.
 */
public class TransCallNamedPipeResponse extends SmbComTransactionResponse {

        assertEquals(2, response.action);
    }

    @Test
    void testSetServerFid() {
        response.serverFid = 456;
        assertEquals(456, response.serverFid);
    }

    @Test
    void testToString() {
        // Set up the response object with test values
        response.fid = 1;
        response.fileAttributes = 2;
        response.lastWriteTime = 3;
        response.dataSize = 4;

        assertFalse(response.canReuse(otherContext, false));
    }

    @Test
    @DisplayName("Should validate response correctly")
    void testIsValid() throws Exception {
        // Setup valid response
        setResponseAsReceived(response);
        setPrivateField(response, "dialectRevision", 0x0311);
        setPrivateField(response, "securityMode", Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED);

    client = TestClient(app)
    response = client.post("/optional-str")
    assert response.status_code == 200, response.text
    assert response.json() == {"p": None}


def test_model_optional_str_missing():
    client = TestClient(app)
    response = client.post("/model-optional-str")
    assert response.status_code == 422, response.text
    assert response.json() == {
        "detail": [
            {

            final CorsHandler handler = factory.get(origin);
            if (handler != null) {
                handler.process(origin, request, response);

                if (OPTIONS.equals(httpRequest.getMethod())) {
                    final HttpServletResponse httpResponse = (HttpServletResponse) response;
                    httpResponse.setStatus(HttpServletResponse.SC_ACCEPTED);
                    return;
                }

/**
 * The RuleManager interface provides methods to manage rules for processing response data.
 * It allows adding, retrieving, and removing rules, as well as checking for their existence.
 */
public interface RuleManager {

    /**
     * Retrieves the rule associated with the given response data.
     *
     * @param responseData the response data for which the rule is to be retrieved

                                 endpoint_url='http://localhost:9000',
                                 aws_access_key_id=response['Credentials']['AccessKeyId'],
                                 aws_secret_access_key=response['Credentials']['SecretAccessKey'],
                                 aws_session_token=response['Credentials']['SessionToken'],
                                 config=Config(signature_version='s3v4'),

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        int result = response.readBytesWireFormat(buffer, bufferIndex);

        assertEquals(8, result);
        assertNotNull(response.getResults());
        // Even with -1, the do-while loop executes at least once due to the bug
        assertEquals(1, response.getResults().length);
    }

    @Test