tokenUrl="token",
    auto_error=True,
    scopes={"read": "Read access", "write": "Write access"},
)


async def get_token(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
    return token


app = FastAPI(dependencies=[Depends(get_token)])


@app.get("/")
async def root():
    return {"message": "Hello World"}


@app.get(
    "/with-oauth2-scheme",

    tokenUrl="/api/oauth/token",
    scopes={"read": "Read access", "write": "Write access"},
)


async def get_token(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
    return token


app = FastAPI(dependencies=[Depends(get_token)])


@app.get("/admin", dependencies=[Security(get_token, scopes=["read", "write"])])
async def read_admin():
    return {"message": "Admin Access"}


client = TestClient(app)

    }

    private static SpnegoToken getToken(final byte[] token, final int off, final int len) throws SpnegoException {
        byte[] b = new byte[len];
        if (off == 0 && token.length == len) {
            b = token;
        } else {
            System.arraycopy(token, off, b, 0, len);
        }
        return getToken(b);
    }

    private static SpnegoToken getToken(final byte[] token) throws SpnegoException {

        int securityBufferOffset = SMBUtil.readInt2(buffer, bodyOffset + 12);
        byte[] actualToken = new byte[TEST_TOKEN.length];
        System.arraycopy(buffer, headerStart + securityBufferOffset, actualToken, 0, TEST_TOKEN.length);
        assertArrayEquals(TEST_TOKEN, actualToken);
    }

    @Test
    @DisplayName("Should write correct bytes to wire format without session binding")

    response = client.get("/items")
    assert response.status_code == 401, response.text
    assert response.json() == {"detail": "Not authenticated"}
    assert response.headers["WWW-Authenticate"] == "Bearer"


def test_token(client: TestClient):
    response = client.get("/items", headers={"Authorization": "Bearer testtoken"})
    assert response.status_code == 200, response.text
    assert response.json() == {"token": "testtoken"}

        this.transform = transform;
    }

    /**
     * Get remote memory key
     *
     * @return remote memory key (token)
     */
    public int getRemoteKey() {
        return transform.getToken();
    }

    /**
     * Get remote memory address
     *
     * @return remote memory address (offset)
     */
    public long getAddress() {
        return transform.getOffset();
    }

    /**

                    .execute()
                    .actionGet(settings.getIndicesTimeout());

            final List<AnalyzeToken> readingTokenList = readingResponse.getTokens();
            final List<AnalyzeToken> termTokenList = termResponse.getTokens();

            final StringBuilder readingBuf = new StringBuilder(text.length());
            if (readingTokenList != null && termTokenList != null) {

     */
    public long getOffset() {
        return offset;
    }

    /**
     * Get RDMA token
     *
     * @return RDMA provider token
     */
    public int getToken() {
        return token;
    }

    /**
     * Get buffer length
     *
     * @return buffer length
     */
    public int getLength() {
        return length;
    }

    /**

    response = client.get("/users/me")
    assert response.status_code == 401, response.text
    assert response.json() == {"detail": "Not authenticated"}
    assert response.headers["WWW-Authenticate"] == "Bearer"


def test_token(client: TestClient):
    response = client.get("/users/me", headers={"Authorization": "Bearer testtoken"})
    assert response.status_code == 200, response.text
    assert response.json() == {

                    .execute()
                    .actionGet(settings.getIndicesTimeout());

            final List<AnalyzeToken> termTokenList = termResponse.getTokens();
            if (termTokenList.isEmpty()) {
                return text;
            }

            return termTokenList.get(0).getTerm();
        }
    }