}

    @Test
    @DisplayName("getRequest should return the same request instance")
    void testGetRequest() {
        // Verify getRequest returns the exact same instance
        SmbNegotiationRequest request = negotiation.getRequest();
        assertSame(mockRequest, request);

        // Verify multiple calls return the same instance
        assertSame(request, negotiation.getRequest());
    }

<img src="/img/tutorial/bigger-applications/image01.png">

## Include the same router multiple times with different `prefix` { #include-the-same-router-multiple-times-with-different-prefix }

You can also use `.include_router()` multiple times with the *same* router using different prefixes.

This could be useful, for example, to expose the same API under different prefixes, e.g. `/api/v1` and `/api/latest`.

You would have **one single `engine` object** for all your code to connect to the same database.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}

Using `check_same_thread=False` allows FastAPI to use the same SQLite database in different threads. This is necessary as **one single request** could use **more than one thread** (for example in dependencies).

And these same full-stack generators were the base of the [**FastAPI** Project Generators](project-generation.md){.internal-link target=_blank}.

/// info

Flask-apispec was created by the same Marshmallow developers.

///

/// check | Inspired **FastAPI** to

Generate the OpenAPI schema automatically, from the same code that defines serialization and validation.

///

    for (int i = 0; i < keyBits; i++) {
      int same = 0x0; // bitset for output bits with same values
      int diff = 0x0; // bitset for output bits with different values
      int count = 0;
      // originally was 2 * Math.log(...), making it try more times to avoid flakiness issues
      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {

        assertSame(dfs, context.getDfs(), "Should return same instance on multiple calls");
    }

    @Test
    @DisplayName("getNameServiceClient should return initialized name service client")
    void testGetNameServiceClient() {
        // When
        NameServiceClient nameServiceClient = context.getNameServiceClient();

        // Then
        assertNotNull(nameServiceClient, "Name service client should not be null");

///

And we are using this model to declare our input and the same model to declare our output:

{* ../../docs_src/response_model/tutorial002_py310.py hl[16] *}

Now, whenever a browser is creating a user with a password, the API will return the same password in the response.

In this case, it might not be a problem, because it's the same user sending the password.

        // Second call should return cached value (same as first)
        Subject second = auth.getSubject();
        if (first == null && second == null) {
            // Both null - caching is working
            assertNull(second, "Second getSubject should return same result as first (both null)");
        } else if (first != null && second != null) {
            // Both non-null - should be same instance

* **Machine Learning**: it normally requires lots of "matrix" and "vector" multiplications. Think of a huge spreadsheet with numbers and multiplying all of them together at the same time.

This is the same mechanism used when you give permissions while logging in with Facebook, Google, GitHub, etc:

<img src="/img/tutorial/security/image11.png">

## JWT token with scopes { #jwt-token-with-scopes }

Now, modify the token *path operation* to return the scopes requested.