} catch (Exception e) {
            // Expected
        }
        long duration = System.currentTimeMillis() - startTime;

        // Test should complete in under 1 second (much less than the original 25+ seconds)
        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

            // Verify overwrite
            assertEquals(concreteImplementation, cacheMap.get(key));
            assertNotEquals(oldEntry, cacheMap.get(key));
        }
    }

    @Nested
    @DisplayName("Complex Scenarios Tests")
    class ComplexScenariosTests {

        @Test
        @DisplayName("Should handle multiple fixup operations")
        void testMultipleFixupOperations() {

        assertEquals(type, exception.getType());
        assertEquals(message, exception.getMessage());
    }

    @Test
    public void test_exceptionInComplexScenario() {
        // Test exception in a more complex scenario
        InvalidAccessTokenException exception = null;
        String expectedType = "Bearer";
        String expectedMessage = "Token has expired";

        // Simulate a token validation scenario

        assertNotSame(loginException.getMessageCode(), logoutException.getMessageCode());
    }

    @Test
    public void test_complexMessageCode() {
        // Setup - test with a complex message code that has parameters
        final String errorDetail = "Authentication failed";
        final VaMessenger<FessMessages> complexMessageCode =

But before that, handling asynchronous code was quite more complex and difficult.

In previous versions of Python, you could have used threads or [Gevent](https://www.gevent.org/). But the code is way more complex to understand, debug, and think about.

    public void test_query_complexFessSyntax() {
        final String query = "title:\"security policy\"^2 OR (+security +policy (guide OR document))";
        final IntentDetectionResult result = IntentDetectionResult.search(query, "complex query");

        assertEquals(query, result.getQuery());
    }

    @Test
    public void test_faq_complexFessSyntax() {
        final String query = "+\"OpenSearch\" (configuration OR settings OR config)";

They tend to require more complex configurations, a message/job queue manager, like RabbitMQ or Redis, but they allow you to run background tasks in multiple processes, and especially, in multiple servers.

        manager.process(request, response, chain);

        assertEquals(201, response.getStatus());
        assertEquals("application/json", response.getHeader("Content-Type"));
        assertEquals("Complex response", response.getWrittenContent());
        assertTrue(chain.wasDoFilterCalled());
    }

    // Test implementation classes

    private static class TestWebApiManager implements WebApiManager {

        }

        @Test
        @DisplayName("Should decode array correctly")
        void testDecode() throws NdrException {
            // Given: Mocked buffer data with pre-created entries to avoid complex entry decode chain
            samr.SamrSamArray array = new samr.SamrSamArray();
            array.entries = new samr.SamrSamEntry[1]; // Pre-populate to avoid decoding
            array.entries[0] = new samr.SamrSamEntry();

To send data, you should use one of: `POST` (the more common), `PUT`, `DELETE` or `PATCH`.

Sending a body with a `GET` request has an undefined behavior in the specifications, nevertheless, it is supported by FastAPI, only for very complex/extreme use cases.

As it is discouraged, the interactive docs with Swagger UI won't show the documentation for the body when using `GET`, and proxies in the middle might not support it.

///