return value;
        }
        return defaultValue;
    }

    /**
     * Creates a new DataStoreParams instance with a copy of the current parameters.
     * This provides an independent copy that can be modified without affecting the original.
     *
     * @return a new DataStoreParams instance containing a copy of the current parameters
     */
    public DataStoreParams newInstance() {

        assertNull(pc.getPassword());
        verify(spyAuth, times(1)).getPasswordAsCharArray();
    }

    @Test
    @DisplayName("clone: copies fields and cached subject; instances are independent")
    void testCloneCopiesFieldsAndIndependence() throws Exception {
        // Use configuration-based constructor to also exercise copying of configuration/service fields

            assertEquals(type, iate.getType());
            assertEquals(message, e.getMessage());
        }
    }

    public void test_multipleExceptionInstances() {
        // Test multiple instances are independent
        InvalidAccessTokenException exception1 = new InvalidAccessTokenException("Type1", "Message1");
        InvalidAccessTokenException exception2 = new InvalidAccessTokenException("Type2", "Message2");

        SmbNegotiation anotherNegotiation =
                new SmbNegotiation(anotherRequest, anotherResponse, anotherRequestBuffer, anotherResponseBuffer);

        // Verify the instances are independent
        assertNotSame(negotiation.getRequest(), anotherNegotiation.getRequest());
        assertNotSame(negotiation.getResponse(), anotherNegotiation.getResponse());

    void testInstantiation() {
        TestLocking t = new TestLocking();
        assertNotNull(t, "TestLocking instance should not be null");
    }

    @Test
    @DisplayName("Field values are independent across instances")
    void testIndependentInstances() {
        TestLocking t1 = new TestLocking();
        TestLocking t2 = new TestLocking();

        // Set different values
        t1.numThreads = 2;

That's what we'll solve, let's load the model before the requests are handled, but only right before the application starts receiving requests, not while  the code is being loaded.

## Lifespan { #lifespan }

        // Document list size should remain the same
        assertEquals(1, result.getDocumentList().size());
    }

    public void test_multipleBuilds() {
        // Test that each builder creates independent results
        // Create first result with one document
        SearchResult.SearchResultBuilder builder1 = SearchResult.create();
        Map<String, Object> doc1 = new HashMap<>();
        doc1.put("id", "1");

        // Create a copy
        DataStoreParams copy = dataStoreParams.newInstance();

        // Modify original
        dataStoreParams.put("key5", "value5");

        // Verify copy is independent
        assertTrue(dataStoreParams.containsKey("key5"));
        assertFalse(copy.containsKey("key5"));

        // Get as map and verify
        Map<String, Object> map = dataStoreParams.asMap();

Now let's go back a bit and understand what is all that.

The `password` "flow" is one of the ways ("flows") defined in OAuth2, to handle security and authentication.

OAuth2 was designed so that the backend or API could be independent of the server that authenticates the user.

But in this case, the same **FastAPI** application will handle the API and the authentication.

So, let's review it from that simplified point of view:

covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.

  1. You may copy and distribute verbatim copies of the Library's