Trans2GetDfsReferral(final String filename) {
        this(filename, 3);
    }

    Trans2GetDfsReferral(final String filename, final int maxReferralLevel) {
        this.maxReferralLevel = maxReferralLevel;
        path = filename;
        command = SMB_COM_TRANSACTION2;
        subCommand = TRANS2_GET_DFS_REFERRAL;
        totalDataCount = 0;
        maxParameterCount = 0;
        maxDataCount = 4096;
        maxSetupCount = (byte) 0x00;

func guessIsLoginSTSReq(req *http.Request) bool {
	if req == nil {
		return false
	}
	return strings.HasPrefix(req.URL.Path, loginPathPrefix) ||
		(req.Method == http.MethodPost && req.URL.Path == SlashSeparator &&
			getRequestAuthType(req) == authTypeSTS)

    }

    @Test
    @DisplayName("sendrecv SMB2 path issues IOCTL and returns response length")
    void testSendRecvSmb2() throws IOException, CIFSException {
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

        // ensureOpen path
        when(tree.isSMB2()).thenReturn(true);

            _dst.enc_ndr_referent(this.path, 1);
            _dst.enc_ndr_referent(this.comment, 1);
            _dst.enc_ndr_long(this.state);
            _dst.enc_ndr_long(this.num_stores);
            _dst.enc_ndr_referent(this.stores, 1);

            if (this.path != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.path);

            }

from fastapi import FastAPI, Path

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    *,
    item_id: int = Path(title="The ID of the item to get", gt=0, le=1000),
    q: str,
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})

			}
		case "Endpoint":
			z.Endpoint, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Endpoint")
				return
			}
		case "Path":
			z.Path, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "Creds":
			var zb0003 uint32
			zb0003, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Creds")

    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {
                "/": {
                    "get": {
                        "summary": "Get Root",
                        "operationId": "get_root__get",
                        "responses": {

    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "openapi": "3.1.0",
        "info": {"title": "FastAPI", "version": "0.1.0"},
        "paths": {
            "/items/": {
                "get": {
                    "responses": {
                        "200": {
                            "description": "Successful Response",

        // Verify session.send was called
        verify(session).send(request, response);
        assertEquals(123, request.tid);
        // For A: service with DFS, path should be modified (share name is uppercased)
        assertEquals("\\testHost\\TESTSHARE\\testPath", request.path);
        assertEquals(ServerMessageBlock.FLAGS2_RESOLVE_PATHS_IN_DFS, request.flags2 & ServerMessageBlock.FLAGS2_RESOLVE_PATHS_IN_DFS);
    }

    @Test

            "license": {
                "name": "Apache 2.0",
                "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
            },
            "version": "0.0.1",
        },
        "paths": {
            "/items/": {
                "get": {
                    "summary": "Read Items",
                    "operationId": "read_items_items__get",
                    "responses": {